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
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 // add here SWIG version check
 475
 476 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 477 // disable Swig-dependent warnings
 478
 479 // 'identifier1' has C-linkage specified,
 480 // but returns UDT 'identifier2' which is incompatible with C
 481 #pragma warning(disable: 4190)
 482
 483 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 484 #pragma warning(disable: 4800)
 485
 486 // debug info too long etc etc
 487 #pragma warning(disable: 4786)
 488 #endif
 489
 490
 491 #include <stdexcept>
 492
 493
 494 #include <string>
 495
 496
 497 #include <vector>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <map>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <utility>
 508
 509
 510 typedef float floatp;
 511
 512 SWIGINTERN floatp *new_floatp(){
 513   return new float();
 514 }
 515 SWIGINTERN void delete_floatp(floatp *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void floatp_assign(floatp *self,float value){
 519   *self = value;
 520 }
 521 SWIGINTERN float floatp_value(floatp *self){
 522   return *self;
 523 }
 524 SWIGINTERN float *floatp_cast(floatp *self){
 525   return self;
 526 }
 527 SWIGINTERN floatp *floatp_frompointer(float *t){
 528   return (floatp *) t;
 529 }
 530
 531 typedef int intp;
 532
 533 SWIGINTERN intp *new_intp(){
 534   return new int();
 535 }
 536 SWIGINTERN void delete_intp(intp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void intp_assign(intp *self,int value){
 540   *self = value;
 541 }
 542 SWIGINTERN int intp_value(intp *self){
 543   return *self;
 544 }
 545 SWIGINTERN int *intp_cast(intp *self){
 546   return self;
 547 }
 548 SWIGINTERN intp *intp_frompointer(int *t){
 549   return (intp *) t;
 550 }
 551
 552 typedef double doublep;
 553
 554 SWIGINTERN doublep *new_doublep(){
 555   return new double();
 556 }
 557 SWIGINTERN void delete_doublep(doublep *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void doublep_assign(doublep *self,double value){
 561   *self = value;
 562 }
 563 SWIGINTERN double doublep_value(doublep *self){
 564   return *self;
 565 }
 566 SWIGINTERN double *doublep_cast(doublep *self){
 567   return self;
 568 }
 569 SWIGINTERN doublep *doublep_frompointer(double *t){
 570   return (doublep *) t;
 571 }
 572
 573 typedef unsigned int uintp;
 574
 575 SWIGINTERN uintp *new_uintp(){
 576   return new unsigned int();
 577 }
 578 SWIGINTERN void delete_uintp(uintp *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 582   *self = value;
 583 }
 584 SWIGINTERN unsigned int uintp_value(uintp *self){
 585   return *self;
 586 }
 587 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 588   return self;
 589 }
 590 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 591   return (uintp *) t;
 592 }
 593
 594 typedef unsigned short ushortp;
 595
 596 SWIGINTERN ushortp *new_ushortp(){
 597   return new unsigned short();
 598 }
 599 SWIGINTERN void delete_ushortp(ushortp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 609   return self;
 610 }
 611 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 612   return (ushortp *) t;
 613 }
 614
 615 unsigned int int_to_uint(int x) {
 616    return (unsigned int) x;
 617 }
 618
 619
 620 using namespace Dali;
 621 using namespace Dali::Toolkit;
 622
 623 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 624 {
 625   bool result = false;
 626   try
 627   {
 628     // C++ code. DALi uses Handle <-> Body design pattern.
 629     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 630     // Handles in DALi can be converted into a boolean type
 631     // to check if the handle has a valid body attached to it.
 632     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 633     if( *self )
 634     {
 635       result = true;
 636     }
 637     else
 638     {
 639       result = false;
 640     }
 641   }
 642   catch (std::out_of_range& e)
 643   {
 644     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 645     return 0;
 646   }
 647   catch (std::exception& e)
 648   {
 649     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (DaliException e)
 653   {
 654     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 655     return 0;
 656   }
 657   catch (...)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 660     return 0;
 661   }
 662   return result;
 663 }
 664
 665 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 666 {
 667   bool result = false;
 668   try
 669   {
 670     // C++ code. Check if two handles reference the same implemtion
 671     if( *self == rhs)
 672     {
 673       result = true;
 674     }
 675     else
 676     {
 677       result = false;
 678     }
 679   }
 680   catch (std::out_of_range& e)
 681   {
 682     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 683     return 0;
 684   }
 685   catch (std::exception& e)
 686   {
 687     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (DaliException e)
 691   {
 692     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 693     return 0;
 694   }
 695   catch (...)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 698     return 0;
 699   }
 700   return result;
 701 }
 702
 703
 704 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 705      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 706    }
 707 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){
 708      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 709    }
 710 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 711         std::vector< Dali::TouchPoint >* pv = 0;
 712         if (capacity >= 0) {
 713           pv = new std::vector< Dali::TouchPoint >();
 714           pv->reserve(capacity);
 715        } else {
 716           throw std::out_of_range("capacity");
 717        }
 718        return pv;
 719       }
 720 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 721         if (index>=0 && index<(int)self->size())
 722           return (*self)[index];
 723         else
 724           throw std::out_of_range("index");
 725       }
 726 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 727         if (index>=0 && index<(int)self->size())
 728           return (*self)[index];
 729         else
 730           throw std::out_of_range("index");
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 733         if (index>=0 && index<(int)self->size())
 734           (*self)[index] = val;
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 739         self->insert(self->end(), values.begin(), values.end());
 740       }
 741 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (count < 0)
 745           throw std::out_of_range("count");
 746         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 747           throw std::invalid_argument("invalid range");
 748         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 749       }
 750 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 751         if (index>=0 && index<(int)self->size()+1)
 752           self->insert(self->begin()+index, x);
 753         else
 754           throw std::out_of_range("index");
 755       }
 756 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 757         if (index>=0 && index<(int)self->size()+1)
 758           self->insert(self->begin()+index, values.begin(), values.end());
 759         else
 760           throw std::out_of_range("index");
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 763         if (index>=0 && index<(int)self->size())
 764           self->erase(self->begin() + index);
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 769         if (index < 0)
 770           throw std::out_of_range("index");
 771         if (count < 0)
 772           throw std::out_of_range("count");
 773         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 774           throw std::invalid_argument("invalid range");
 775         self->erase(self->begin()+index, self->begin()+index+count);
 776       }
 777 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         return new std::vector< Dali::TouchPoint >(count, value);
 781       }
 782 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 783         std::reverse(self->begin(), self->end());
 784       }
 785 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 786         if (index < 0)
 787           throw std::out_of_range("index");
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 791           throw std::invalid_argument("invalid range");
 792         std::reverse(self->begin()+index, self->begin()+index+count);
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 795         if (index < 0)
 796           throw std::out_of_range("index");
 797         if (index+values.size() > self->size())
 798           throw std::out_of_range("index");
 799         std::copy(values.begin(), values.end(), self->begin()+index);
 800       }
 801 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 802          return self->Empty();
 803       }
 804 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 805         return self->GetConnectionCount();
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 808           self->Connect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 811           self->Disconnect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 814           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 815 /*@SWIG@*/ self->Emit( arg );
 816       }
 817 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 818          return self->Empty();
 819       }
 820 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 821         return self->GetConnectionCount();
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 824           self->Connect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 827           self->Disconnect( func );
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 830           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 831 /*@SWIG@*/ self->Emit( arg );
 832       }
 833 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 834          return self->Empty();
 835       }
 836 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){
 837         return self->GetConnectionCount();
 838       }
 839 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 *)){
 840           self->Connect( func );
 841       }
 842 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 *)){
 843           self->Disconnect( func );
 844       }
 845 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){
 846           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 847 /*@SWIG@*/ self->Emit( arg );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 856           self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 859           self->Disconnect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 866          return self->Empty();
 867       }
 868 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 869         return self->GetConnectionCount();
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 872           self->Connect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 875           self->Disconnect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 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){
 882          return self->Empty();
 883       }
 884 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){
 885         return self->GetConnectionCount();
 886       }
 887 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 &)){
 888         self->Connect( func );
 889       }
 890 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 &)){
 891         self->Disconnect( func );
 892       }
 893 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){
 894         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg1, arg2 );
 896       }
 897 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){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904         self->Connect( func );
 905       }
 906 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 &)){
 907         self->Disconnect( func );
 908       }
 909 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){
 910         return self->Emit( arg1, arg2 );
 911       }
 912 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){
 913          return self->Empty();
 914       }
 915 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){
 916         return self->GetConnectionCount();
 917       }
 918 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 &)){
 919         self->Connect( func );
 920       }
 921 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 &)){
 922         self->Disconnect( func );
 923       }
 924 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){
 925         return self->Emit( arg1, arg2 );
 926       }
 927 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){
 928          return self->Empty();
 929       }
 930 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){
 931         return self->GetConnectionCount();
 932       }
 933 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 &)){
 934         self->Connect( func );
 935       }
 936 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 &)){
 937         self->Disconnect( func );
 938       }
 939 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){
 940         return self->Emit( arg1, arg2 );
 941       }
 942 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 943          return self->Empty();
 944       }
 945 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 946         return self->GetConnectionCount();
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 949           self->Connect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 952           self->Disconnect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 955           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 956 /*@SWIG@*/ self->Emit( arg );
 957       }
 958 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 959          return self->Empty();
 960       }
 961 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){
 962         return self->GetConnectionCount();
 963       }
 964 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 &)){
 965           self->Connect( func );
 966       }
 967 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 &)){
 968           self->Disconnect( func );
 969       }
 970 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){
 971           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 972 /*@SWIG@*/ self->Emit( arg );
 973       }
 974 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 975          return self->Empty();
 976       }
 977 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){
 978         return self->GetConnectionCount();
 979       }
 980 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 &)){
 981           self->Connect( func );
 982       }
 983 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 &)){
 984           self->Disconnect( func );
 985       }
 986 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){
 987           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 988 /*@SWIG@*/ self->Emit( arg );
 989       }
 990 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 991          return self->Empty();
 992       }
 993 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){
 994         return self->GetConnectionCount();
 995       }
 996 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 &)){
 997           self->Connect( func );
 998       }
 999 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 &)){
1000           self->Disconnect( func );
1001       }
1002 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){
1003           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1004 /*@SWIG@*/ self->Emit( arg );
1005       }
1006 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){
1007          return self->Empty();
1008       }
1009 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){
1010         return self->GetConnectionCount();
1011       }
1012 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 &)){
1013         self->Connect( func );
1014       }
1015 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 &)){
1016         self->Disconnect( func );
1017       }
1018 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){
1019         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1020 /*@SWIG@*/ self->Emit( arg1, arg2 );
1021       }
1022 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){
1023          return self->Empty();
1024       }
1025 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){
1026         return self->GetConnectionCount();
1027       }
1028 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 &)){
1029         self->Connect( func );
1030       }
1031 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 &)){
1032         self->Disconnect( func );
1033       }
1034 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){
1035         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1036 /*@SWIG@*/ self->Emit( arg1, arg2 );
1037       }
1038 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){
1039          return self->Empty();
1040       }
1041 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){
1042         return self->GetConnectionCount();
1043       }
1044 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 &)){
1045         self->Connect( func );
1046       }
1047 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 &)){
1048         self->Disconnect( func );
1049       }
1050 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){
1051         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1052 /*@SWIG@*/ self->Emit( arg1, arg2 );
1053       }
1054 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1055          return self->Empty();
1056       }
1057 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1058         return self->GetConnectionCount();
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1061           self->Connect( func );
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1064           self->Disconnect( func );
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1067           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1068 /*@SWIG@*/ self->Emit( arg );
1069       }
1070 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){
1071          return self->Empty();
1072       }
1073 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){
1074         return self->GetConnectionCount();
1075       }
1076 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)){
1077           return self->Connect( func );
1078       }
1079 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)){
1080           self->Disconnect( func );
1081       }
1082 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){
1083           self->Emit( arg1, arg3 );
1084       }
1085 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){
1086          return self->Empty();
1087       }
1088 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){
1089         return self->GetConnectionCount();
1090       }
1091 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)){
1092           return self->Connect( func );
1093       }
1094 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)){
1095           self->Disconnect( func );
1096       }
1097 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){
1098           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1099 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1100       }
1101
1102 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1103          return self->Empty();
1104       }
1105 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1106         return self->GetConnectionCount();
1107       }
1108 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1109           self->Connect( func );
1110       }
1111 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1112           self->Disconnect( func );
1113       }
1114 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1115           return self->Emit();
1116       }
1117
1118 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1119         std::vector< unsigned int >* pv = 0;
1120         if (capacity >= 0) {
1121           pv = new std::vector< unsigned int >();
1122           pv->reserve(capacity);
1123        } else {
1124           throw std::out_of_range("capacity");
1125        }
1126        return pv;
1127       }
1128 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1135         if (index>=0 && index<(int)self->size())
1136           return (*self)[index];
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1141         if (index>=0 && index<(int)self->size())
1142           (*self)[index] = val;
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1147         self->insert(self->end(), values.begin(), values.end());
1148       }
1149 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1150         if (index < 0)
1151           throw std::out_of_range("index");
1152         if (count < 0)
1153           throw std::out_of_range("count");
1154         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1155           throw std::invalid_argument("invalid range");
1156         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, x);
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1165         if (index>=0 && index<(int)self->size()+1)
1166           self->insert(self->begin()+index, values.begin(), values.end());
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1171         if (index>=0 && index<(int)self->size())
1172           self->erase(self->begin() + index);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1177         if (index < 0)
1178           throw std::out_of_range("index");
1179         if (count < 0)
1180           throw std::out_of_range("count");
1181         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1182           throw std::invalid_argument("invalid range");
1183         self->erase(self->begin()+index, self->begin()+index+count);
1184       }
1185 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         return new std::vector< unsigned int >(count, value);
1189       }
1190 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1191         std::reverse(self->begin(), self->end());
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1199           throw std::invalid_argument("invalid range");
1200         std::reverse(self->begin()+index, self->begin()+index+count);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1203         if (index < 0)
1204           throw std::out_of_range("index");
1205         if (index+values.size() > self->size())
1206           throw std::out_of_range("index");
1207         std::copy(values.begin(), values.end(), self->begin()+index);
1208       }
1209 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1210         return std::find(self->begin(), self->end(), value) != self->end();
1211       }
1212 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1213         int index = -1;
1214         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1215         if (it != self->end())
1216           index = (int)(it - self->begin());
1217         return index;
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1222         if (rit != self->rend())
1223           index = (int)(self->rend() - 1 - rit);
1224         return index;
1225       }
1226 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1227         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1228         if (it != self->end()) {
1229           self->erase(it);
1230           return true;
1231         }
1232         return false;
1233       }
1234 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){
1235         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1236         if (capacity >= 0) {
1237           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1238           pv->reserve(capacity);
1239        } else {
1240           throw std::out_of_range("capacity");
1241        }
1242        return pv;
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           return (*self)[index];
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           (*self)[index] = val;
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 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){
1263         self->insert(self->end(), values.begin(), values.end());
1264       }
1265 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){
1266         if (index < 0)
1267           throw std::out_of_range("index");
1268         if (count < 0)
1269           throw std::out_of_range("count");
1270         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1271           throw std::invalid_argument("invalid range");
1272         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, x);
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size()+1)
1282           self->insert(self->begin()+index, values.begin(), values.end());
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 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){
1287         if (index>=0 && index<(int)self->size())
1288           self->erase(self->begin() + index);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 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){
1293         if (index < 0)
1294           throw std::out_of_range("index");
1295         if (count < 0)
1296           throw std::out_of_range("count");
1297         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1298           throw std::invalid_argument("invalid range");
1299         self->erase(self->begin()+index, self->begin()+index+count);
1300       }
1301 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){
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1305       }
1306 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){
1307         std::reverse(self->begin(), self->end());
1308       }
1309 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){
1310         if (index < 0)
1311           throw std::out_of_range("index");
1312         if (count < 0)
1313           throw std::out_of_range("count");
1314         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1315           throw std::invalid_argument("invalid range");
1316         std::reverse(self->begin()+index, self->begin()+index+count);
1317       }
1318 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){
1319         if (index < 0)
1320           throw std::out_of_range("index");
1321         if (index+values.size() > self->size())
1322           throw std::out_of_range("index");
1323         std::copy(values.begin(), values.end(), self->begin()+index);
1324       }
1325 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1326         std::vector< Dali::Actor >* pv = 0;
1327         if (capacity >= 0) {
1328           pv = new std::vector< Dali::Actor >();
1329           pv->reserve(capacity);
1330        } else {
1331           throw std::out_of_range("capacity");
1332        }
1333        return pv;
1334       }
1335 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1342         if (index>=0 && index<(int)self->size())
1343           return (*self)[index];
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1348         if (index>=0 && index<(int)self->size())
1349           (*self)[index] = val;
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1354         self->insert(self->end(), values.begin(), values.end());
1355       }
1356 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1357         if (index < 0)
1358           throw std::out_of_range("index");
1359         if (count < 0)
1360           throw std::out_of_range("count");
1361         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1362           throw std::invalid_argument("invalid range");
1363         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, x);
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1372         if (index>=0 && index<(int)self->size()+1)
1373           self->insert(self->begin()+index, values.begin(), values.end());
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1378         if (index>=0 && index<(int)self->size())
1379           self->erase(self->begin() + index);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1384         if (index < 0)
1385           throw std::out_of_range("index");
1386         if (count < 0)
1387           throw std::out_of_range("count");
1388         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1389           throw std::invalid_argument("invalid range");
1390         self->erase(self->begin()+index, self->begin()+index+count);
1391       }
1392 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         return new std::vector< Dali::Actor >(count, value);
1396       }
1397 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1398         std::reverse(self->begin(), self->end());
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1401         if (index < 0)
1402           throw std::out_of_range("index");
1403         if (count < 0)
1404           throw std::out_of_range("count");
1405         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1406           throw std::invalid_argument("invalid range");
1407         std::reverse(self->begin()+index, self->begin()+index+count);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1410         if (index < 0)
1411           throw std::out_of_range("index");
1412         if (index+values.size() > self->size())
1413           throw std::out_of_range("index");
1414         std::copy(values.begin(), values.end(), self->begin()+index);
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 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 &)){
1423           self->Connect( func );
1424       }
1425 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 &)){
1426           self->Disconnect( func );
1427       }
1428 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){
1429           return self->Emit( arg );
1430       }
1431 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){
1432          return self->Empty();
1433       }
1434 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){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438         self->Connect( func );
1439       }
1440 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)){
1441         self->Disconnect( func );
1442       }
1443 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){
1444         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg1, arg2 );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1448          return self->Empty();
1449       }
1450 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){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454         self->Connect( func );
1455       }
1456 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)){
1457         self->Disconnect( func );
1458       }
1459 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){
1460         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470         self->Connect( func );
1471       }
1472 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)){
1473         self->Disconnect( func );
1474       }
1475 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){
1476         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg1, arg2 );
1478       }
1479 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){
1480          return self->Empty();
1481       }
1482 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){
1483         return self->GetConnectionCount();
1484       }
1485 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)){
1486         self->Connect( func );
1487       }
1488 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)){
1489         self->Disconnect( func );
1490       }
1491 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){
1492         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg1, arg2 );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1496          return self->Empty();
1497       }
1498 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1499         return self->GetConnectionCount();
1500       }
1501 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)){
1502           self->Connect( func );
1503       }
1504 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)){
1505           self->Disconnect( func );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1508           return self->Emit( arg );
1509       }
1510 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1511          return self->Empty();
1512       }
1513 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1514         return self->GetConnectionCount();
1515       }
1516 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)){
1517           self->Connect( func );
1518       }
1519 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)){
1520           self->Disconnect( func );
1521       }
1522 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1523           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1524 /*@SWIG@*/ self->Emit( arg );
1525       }
1526 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){
1527          return self->Empty();
1528       }
1529 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){
1530         return self->GetConnectionCount();
1531       }
1532 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)){
1533           return self->Connect( func );
1534       }
1535 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)){
1536           self->Disconnect( func );
1537       }
1538 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){
1539           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1540 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1541       }
1542 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1543          return self->Empty();
1544       }
1545 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1546         return self->GetConnectionCount();
1547       }
1548 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)){
1549           self->Connect( func );
1550       }
1551 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)){
1552           self->Disconnect( func );
1553       }
1554 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1555           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1556 /*@SWIG@*/ self->Emit( arg );
1557       }
1558 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){
1559          return self->Empty();
1560       }
1561 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){
1562         return self->GetConnectionCount();
1563       }
1564 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)){
1565           return self->Connect( func );
1566       }
1567 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)){
1568           self->Disconnect( func );
1569       }
1570 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){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1573       }
1574 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){
1575          return self->Empty();
1576       }
1577 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){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1591          return self->Empty();
1592       }
1593 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){
1594         return self->GetConnectionCount();
1595       }
1596 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 &)){
1597           self->Connect( func );
1598       }
1599 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 &)){
1600           self->Disconnect( func );
1601       }
1602 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){
1603           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1604 /*@SWIG@*/ self->Emit( arg );
1605       }
1606
1607
1608 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){
1609          return self->Empty();
1610       }
1611 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){
1612         return self->GetConnectionCount();
1613       }
1614 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 &)){
1615         self->Connect( func );
1616       }
1617 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 &)){
1618         self->Disconnect( func );
1619       }
1620 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){
1621         return self->Emit( arg1, arg2 );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 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)){
1630           self->Connect( func );
1631       }
1632 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)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1640          return self->Empty();
1641       }
1642 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1643         return self->GetConnectionCount();
1644       }
1645 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 &)){
1646           self->Connect( func );
1647       }
1648 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 &)){
1649           self->Disconnect( func );
1650       }
1651 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){
1652           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1653 /*@SWIG@*/ self->Emit( arg );
1654       }
1655 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1656          return self->Empty();
1657       }
1658 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){
1659         return self->GetConnectionCount();
1660       }
1661 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)){
1662         self->Connect( func );
1663       }
1664 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)){
1665         self->Disconnect( func );
1666       }
1667 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){
1668         return self->Emit( arg1, arg2 );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1671          return self->Empty();
1672       }
1673 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){
1674         return self->GetConnectionCount();
1675       }
1676 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)){
1677         self->Connect( func );
1678       }
1679 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)){
1680         self->Disconnect( func );
1681       }
1682 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){
1683         return self->Emit( arg1, arg2 );
1684       }
1685
1686
1687 /* ---------------------------------------------------
1688  * C++ director class methods
1689  * --------------------------------------------------- */
1690
1691 #include "dali_wrap.h"
1692
1693 /*
1694  *  Widget director
1695  */
1696 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1697   swig_init_callbacks();
1698 }
1699
1700 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1701 }
1702
1703 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1704   char * jcontentInfo = 0 ;
1705   void * jwindow  ;
1706
1707   if (!swig_callbackOnCreate) {
1708     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1709     return;
1710   } else {
1711     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1712     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1713     swig_callbackOnCreate(jcontentInfo, jwindow);
1714   }
1715 }
1716
1717 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1718   char * jcontentInfo = 0 ;
1719   int jtype  ;
1720
1721   if (!swig_callbackOnTerminate) {
1722     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1723     return;
1724   } else {
1725     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1726     jtype = (int)type;
1727     swig_callbackOnTerminate(jcontentInfo, jtype);
1728   }
1729 }
1730
1731 void SwigDirector_WidgetImpl::OnPause() {
1732   if (!swig_callbackOnPause) {
1733     Dali::Internal::Adaptor::Widget::OnPause();
1734     return;
1735   } else {
1736     swig_callbackOnPause();
1737   }
1738 }
1739
1740 void SwigDirector_WidgetImpl::OnResume() {
1741   if (!swig_callbackOnResume) {
1742     Dali::Internal::Adaptor::Widget::OnResume();
1743     return;
1744   } else {
1745     swig_callbackOnResume();
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1750   void * jwindow  ;
1751
1752   if (!swig_callbackOnResize) {
1753     Dali::Internal::Adaptor::Widget::OnResize(window);
1754     return;
1755   } else {
1756     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1757     swig_callbackOnResize(jwindow);
1758   }
1759 }
1760
1761 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1762   char * jcontentInfo = 0 ;
1763   int jforce  ;
1764
1765   if (!swig_callbackOnUpdate) {
1766     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1767     return;
1768   } else {
1769     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1770     jforce = force;
1771     swig_callbackOnUpdate(jcontentInfo, jforce);
1772   }
1773 }
1774
1775 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1776   void * jslotObserver = 0 ;
1777   void * jcallback = 0 ;
1778
1779   if (!swig_callbackSignalConnected) {
1780     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1781     return;
1782   } else {
1783     jslotObserver = (void *) slotObserver;
1784     jcallback = (void *) callback;
1785     swig_callbackSignalConnected(jslotObserver, jcallback);
1786   }
1787 }
1788
1789 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1790   void * jslotObserver = 0 ;
1791   void * jcallback = 0 ;
1792
1793   if (!swig_callbackSignalDisconnected) {
1794     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1795     return;
1796   } else {
1797     jslotObserver = (void *) slotObserver;
1798     jcallback = (void *) callback;
1799     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1800   }
1801 }
1802
1803 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) {
1804
1805   swig_callbackOnCreate = callbackOnCreate;
1806   swig_callbackOnTerminate = callbackOnTerminate;
1807   swig_callbackOnPause = callbackOnPause;
1808   swig_callbackOnResume = callbackOnResume;
1809   swig_callbackOnResize = callbackOnResize;
1810   swig_callbackOnUpdate = callbackOnUpdate;
1811   swig_callbackSignalConnected = callbackSignalConnected;
1812   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1813 }
1814
1815 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1816   swig_callbackOnCreate = 0;
1817   swig_callbackOnTerminate = 0;
1818   swig_callbackOnPause = 0;
1819   swig_callbackOnResume = 0;
1820   swig_callbackOnResize = 0;
1821   swig_callbackOnUpdate = 0;
1822   swig_callbackSignalConnected = 0;
1823   swig_callbackSignalDisconnected = 0;
1824 }
1825
1826
1827 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1828   swig_init_callbacks();
1829 }
1830
1831 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1832
1833 }
1834
1835
1836 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1837   int jdepth  ;
1838
1839   if (!swig_callbackOnStageConnection) {
1840     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1841     return;
1842   } else {
1843     jdepth = depth;
1844     swig_callbackOnStageConnection(jdepth);
1845   }
1846 }
1847
1848 void SwigDirector_ViewImpl::OnStageDisconnection() {
1849   if (!swig_callbackOnStageDisconnection) {
1850     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1851     return;
1852   } else {
1853     swig_callbackOnStageDisconnection();
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildAdd) {
1861     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildAdd(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1870   void * jchild = 0 ;
1871
1872   if (!swig_callbackOnChildRemove) {
1873     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1874     return;
1875   } else {
1876     jchild = (Dali::Actor *) &child;
1877     swig_callbackOnChildRemove(jchild);
1878   }
1879 }
1880
1881 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1882   int jindex  ;
1883   void * jpropertyValue  ;
1884
1885   if (!swig_callbackOnPropertySet) {
1886     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1887     return;
1888   } else {
1889     jindex = index;
1890     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1891     swig_callbackOnPropertySet(jindex, jpropertyValue);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1896   void * jtargetSize = 0 ;
1897
1898   if (!swig_callbackOnSizeSet) {
1899     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1900     return;
1901   } else {
1902     jtargetSize = (Dali::Vector3 *) &targetSize;
1903     swig_callbackOnSizeSet(jtargetSize);
1904   }
1905 }
1906
1907 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1908   void * janimation = 0 ;
1909   void * jtargetSize = 0 ;
1910
1911   if (!swig_callbackOnSizeAnimation) {
1912     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1913     return;
1914   } else {
1915     janimation = (Dali::Animation *) &animation;
1916     jtargetSize = (Dali::Vector3 *) &targetSize;
1917     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1918   }
1919 }
1920
1921 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1922   bool c_result = SwigValueInit< bool >() ;
1923   unsigned int jresult = 0 ;
1924   void * jarg0 = 0 ;
1925
1926   if (!swig_callbackOnTouchEvent) {
1927     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1928   } else {
1929     jarg0 = (Dali::TouchEvent *) &event;
1930     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1931     c_result = jresult ? true : false;
1932   }
1933   return c_result;
1934 }
1935
1936 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1937   bool c_result = SwigValueInit< bool >() ;
1938   unsigned int jresult = 0 ;
1939   void * jarg0 = 0 ;
1940
1941   if (!swig_callbackOnHoverEvent) {
1942     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1943   } else {
1944     jarg0 = (Dali::HoverEvent *) &event;
1945     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1946     c_result = jresult ? true : false;
1947   }
1948   return c_result;
1949 }
1950
1951 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1952   bool c_result = SwigValueInit< bool >() ;
1953   unsigned int jresult = 0 ;
1954   void * jarg0 = 0 ;
1955
1956   if (!swig_callbackOnKeyEvent) {
1957     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1958   } else {
1959     jarg0 = (Dali::KeyEvent *) &event;
1960     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1961     c_result = jresult ? true : false;
1962   }
1963   return c_result;
1964 }
1965
1966 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1967   bool c_result = SwigValueInit< bool >() ;
1968   unsigned int jresult = 0 ;
1969   void * jarg0 = 0 ;
1970
1971   if (!swig_callbackOnWheelEvent) {
1972     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1973   } else {
1974     jarg0 = (Dali::WheelEvent *) &event;
1975     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1976     c_result = jresult ? true : false;
1977   }
1978   return c_result;
1979 }
1980
1981 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1982   void * jsize = 0 ;
1983   void * jcontainer = 0 ;
1984
1985   if (!swig_callbackOnRelayout) {
1986     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1987     return;
1988   } else {
1989     jsize = (Dali::Vector2 *) &size;
1990     jcontainer = (Dali::RelayoutContainer *) &container;
1991     swig_callbackOnRelayout(jsize, jcontainer);
1992   }
1993 }
1994
1995 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1996   int jpolicy  ;
1997   int jdimension  ;
1998
1999   if (!swig_callbackOnSetResizePolicy) {
2000     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2001     return;
2002   } else {
2003     jpolicy = (int)policy;
2004     jdimension = (int)dimension;
2005     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2006   }
2007 }
2008
2009 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2010   Dali::Vector3 c_result ;
2011   void * jresult = 0 ;
2012
2013   if (!swig_callbackGetNaturalSize) {
2014     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2015   } else {
2016     jresult = (void *) swig_callbackGetNaturalSize();
2017     if (!jresult) {
2018       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2019       return c_result;
2020     }
2021     c_result = *(Dali::Vector3 *)jresult;
2022   }
2023   return c_result;
2024 }
2025
2026 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2027   float c_result = SwigValueInit< float >() ;
2028   float jresult = 0 ;
2029   void * jchild = 0 ;
2030   int jdimension  ;
2031
2032   if (!swig_callbackCalculateChildSize) {
2033     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2034   } else {
2035     jchild = (Dali::Actor *) &child;
2036     jdimension = (int)dimension;
2037     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2038     c_result = (float)jresult;
2039   }
2040   return c_result;
2041 }
2042
2043 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2044   float c_result = SwigValueInit< float >() ;
2045   float jresult = 0 ;
2046   float jwidth  ;
2047
2048   if (!swig_callbackGetHeightForWidth) {
2049     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2050   } else {
2051     jwidth = width;
2052     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2053     c_result = (float)jresult;
2054   }
2055   return c_result;
2056 }
2057
2058 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2059   float c_result = SwigValueInit< float >() ;
2060   float jresult = 0 ;
2061   float jheight  ;
2062
2063   if (!swig_callbackGetWidthForHeight) {
2064     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2065   } else {
2066     jheight = height;
2067     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2068     c_result = (float)jresult;
2069   }
2070   return c_result;
2071 }
2072
2073 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2074   bool c_result = SwigValueInit< bool >() ;
2075   unsigned int jresult = 0 ;
2076   int jdimension  ;
2077
2078   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2079     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2080   } else {
2081     jdimension = (int)dimension;
2082     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2083     c_result = jresult ? true : false;
2084   }
2085   return c_result;
2086 }
2087
2088 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2089   int jdimension  ;
2090
2091   if (!swig_callbackOnCalculateRelayoutSize) {
2092     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2093     return;
2094   } else {
2095     jdimension = (int)dimension;
2096     swig_callbackOnCalculateRelayoutSize(jdimension);
2097   }
2098 }
2099
2100 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2101   float jsize  ;
2102   int jdimension  ;
2103
2104   if (!swig_callbackOnLayoutNegotiated) {
2105     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2106     return;
2107   } else {
2108     jsize = size;
2109     jdimension = (int)dimension;
2110     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2111   }
2112 }
2113
2114 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2115   return Dali::CustomActorImpl::GetExtension();
2116 }
2117
2118 void SwigDirector_ViewImpl::OnInitialize() {
2119   if (!swig_callbackOnInitialize) {
2120     Dali::Toolkit::Internal::Control::OnInitialize();
2121     return;
2122   } else {
2123     swig_callbackOnInitialize();
2124   }
2125 }
2126
2127 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2128   void * jchild = 0 ;
2129
2130   if (!swig_callbackOnControlChildAdd) {
2131     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2132     return;
2133   } else {
2134     jchild = (Dali::Actor *) &child;
2135     swig_callbackOnControlChildAdd(jchild);
2136   }
2137 }
2138
2139 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2140   void * jchild = 0 ;
2141
2142   if (!swig_callbackOnControlChildRemove) {
2143     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2144     return;
2145   } else {
2146     jchild = (Dali::Actor *) &child;
2147     swig_callbackOnControlChildRemove(jchild);
2148   }
2149 }
2150
2151 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2152   void * jstyleManager  ;
2153   int jchange  ;
2154
2155   if (!swig_callbackOnStyleChange) {
2156     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2157     return;
2158   } else {
2159     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2160     jchange = (int)change;
2161     swig_callbackOnStyleChange(jstyleManager, jchange);
2162   }
2163 }
2164
2165 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2166   bool c_result = SwigValueInit< bool >() ;
2167   unsigned int jresult = 0 ;
2168
2169   if (!swig_callbackOnAccessibilityActivated) {
2170     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2171   } else {
2172     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2173     c_result = jresult ? true : false;
2174   }
2175   return c_result;
2176 }
2177
2178 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2179   bool c_result = SwigValueInit< bool >() ;
2180   unsigned int jresult = 0 ;
2181   void * jgesture  ;
2182
2183   if (!swig_callbackOnAccessibilityPan) {
2184     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2185   } else {
2186     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2187     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2188     c_result = jresult ? true : false;
2189   }
2190   return c_result;
2191 }
2192
2193 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2194   bool c_result = SwigValueInit< bool >() ;
2195   unsigned int jresult = 0 ;
2196   void * jtouchEvent = 0 ;
2197
2198   if (!swig_callbackOnAccessibilityTouch) {
2199     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2200   } else {
2201     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2202     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2203     c_result = jresult ? true : false;
2204   }
2205   return c_result;
2206 }
2207
2208 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2209   bool c_result = SwigValueInit< bool >() ;
2210   unsigned int jresult = 0 ;
2211   unsigned int jisIncrease  ;
2212
2213   if (!swig_callbackOnAccessibilityValueChange) {
2214     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2215   } else {
2216     jisIncrease = isIncrease;
2217     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2218     c_result = jresult ? true : false;
2219   }
2220   return c_result;
2221 }
2222
2223 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2224   bool c_result = SwigValueInit< bool >() ;
2225   unsigned int jresult = 0 ;
2226
2227   if (!swig_callbackOnAccessibilityZoom) {
2228     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2229   } else {
2230     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2231     c_result = jresult ? true : false;
2232   }
2233   return c_result;
2234 }
2235
2236 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2237   if (!swig_callbackOnKeyInputFocusGained) {
2238     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2239     return;
2240   } else {
2241     swig_callbackOnKeyInputFocusGained();
2242   }
2243 }
2244
2245 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2246   if (!swig_callbackOnKeyInputFocusLost) {
2247     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2248     return;
2249   } else {
2250     swig_callbackOnKeyInputFocusLost();
2251   }
2252 }
2253
2254 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2255   Dali::Actor c_result ;
2256   void * jresult = 0 ;
2257   void * jcurrentFocusedActor  ;
2258   int jdirection  ;
2259   unsigned int jloopEnabled  ;
2260
2261   if (!swig_callbackGetNextKeyboardFocusableActor) {
2262     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2263   } else {
2264     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2265     jdirection = (int)direction;
2266     jloopEnabled = loopEnabled;
2267     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2268     if (!jresult) {
2269       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2270       return c_result;
2271     }
2272     c_result = *(Dali::Actor *)jresult;
2273   }
2274   return c_result;
2275 }
2276
2277 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2278   void * jcommitedFocusableActor  ;
2279
2280   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2281     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2282     return;
2283   } else {
2284     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2285     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2286   }
2287 }
2288
2289 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2290   bool c_result = SwigValueInit< bool >() ;
2291   unsigned int jresult = 0 ;
2292
2293   if (!swig_callbackOnKeyboardEnter) {
2294     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2295   } else {
2296     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2297     c_result = jresult ? true : false;
2298   }
2299   return c_result;
2300 }
2301
2302 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2303   void * jpinch = 0 ;
2304
2305   if (!swig_callbackOnPinch) {
2306     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2307     return;
2308   } else {
2309     jpinch = (Dali::PinchGesture *) &pinch;
2310     swig_callbackOnPinch(jpinch);
2311   }
2312 }
2313
2314 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2315   void * jpan = 0 ;
2316
2317   if (!swig_callbackOnPan) {
2318     Dali::Toolkit::Internal::Control::OnPan(pan);
2319     return;
2320   } else {
2321     jpan = (Dali::PanGesture *) &pan;
2322     swig_callbackOnPan(jpan);
2323   }
2324 }
2325
2326 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2327   void * jtap = 0 ;
2328
2329   if (!swig_callbackOnTap) {
2330     Dali::Toolkit::Internal::Control::OnTap(tap);
2331     return;
2332   } else {
2333     jtap = (Dali::TapGesture *) &tap;
2334     swig_callbackOnTap(jtap);
2335   }
2336 }
2337
2338 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2339   void * jlongPress = 0 ;
2340
2341   if (!swig_callbackOnLongPress) {
2342     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2343     return;
2344   } else {
2345     jlongPress = (Dali::LongPressGesture *) &longPress;
2346     swig_callbackOnLongPress(jlongPress);
2347   }
2348 }
2349
2350 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2351   void * jslotObserver = 0 ;
2352   void * jcallback = 0 ;
2353
2354   if (!swig_callbackSignalConnected) {
2355     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2356     return;
2357   } else {
2358     jslotObserver = (void *) slotObserver;
2359     jcallback = (void *) callback;
2360     swig_callbackSignalConnected(jslotObserver, jcallback);
2361   }
2362 }
2363
2364 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2365   void * jslotObserver = 0 ;
2366   void * jcallback = 0 ;
2367
2368   if (!swig_callbackSignalDisconnected) {
2369     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2370     return;
2371   } else {
2372     jslotObserver = (void *) slotObserver;
2373     jcallback = (void *) callback;
2374     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2375   }
2376 }
2377
2378 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2379   return Dali::Toolkit::Internal::Control::GetControlExtension();
2380 }
2381
2382 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) {
2383   swig_callbackOnStageConnection = callbackOnStageConnection;
2384   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2385   swig_callbackOnChildAdd = callbackOnChildAdd;
2386   swig_callbackOnChildRemove = callbackOnChildRemove;
2387   swig_callbackOnPropertySet = callbackOnPropertySet;
2388   swig_callbackOnSizeSet = callbackOnSizeSet;
2389   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2390   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2391   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2392   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2393   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2394   swig_callbackOnRelayout = callbackOnRelayout;
2395   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2396   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2397   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2398   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2399   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2400   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2401   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2402   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2403   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2404   swig_callbackOnInitialize = callbackOnInitialize;
2405   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2406   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2407   swig_callbackOnStyleChange = callbackOnStyleChange;
2408   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2409   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2410   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2411   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2412   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2413   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2414   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2415   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2416   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2417   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2418   swig_callbackOnPinch = callbackOnPinch;
2419   swig_callbackOnPan = callbackOnPan;
2420   swig_callbackOnTap = callbackOnTap;
2421   swig_callbackOnLongPress = callbackOnLongPress;
2422   swig_callbackSignalConnected = callbackSignalConnected;
2423   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2424 }
2425
2426 void SwigDirector_ViewImpl::swig_init_callbacks() {
2427   swig_callbackOnStageConnection = 0;
2428   swig_callbackOnStageDisconnection = 0;
2429   swig_callbackOnChildAdd = 0;
2430   swig_callbackOnChildRemove = 0;
2431   swig_callbackOnPropertySet = 0;
2432   swig_callbackOnSizeSet = 0;
2433   swig_callbackOnSizeAnimation = 0;
2434   swig_callbackOnTouchEvent = 0;
2435   swig_callbackOnHoverEvent = 0;
2436   swig_callbackOnKeyEvent = 0;
2437   swig_callbackOnWheelEvent = 0;
2438   swig_callbackOnRelayout = 0;
2439   swig_callbackOnSetResizePolicy = 0;
2440   swig_callbackGetNaturalSize = 0;
2441   swig_callbackCalculateChildSize = 0;
2442   swig_callbackGetHeightForWidth = 0;
2443   swig_callbackGetWidthForHeight = 0;
2444   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2445   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2446   swig_callbackOnCalculateRelayoutSize = 0;
2447   swig_callbackOnLayoutNegotiated = 0;
2448   swig_callbackOnInitialize = 0;
2449   swig_callbackOnControlChildAdd = 0;
2450   swig_callbackOnControlChildRemove = 0;
2451   swig_callbackOnStyleChange = 0;
2452   swig_callbackOnAccessibilityActivated = 0;
2453   swig_callbackOnAccessibilityPan = 0;
2454   swig_callbackOnAccessibilityTouch = 0;
2455   swig_callbackOnAccessibilityValueChange = 0;
2456   swig_callbackOnAccessibilityZoom = 0;
2457   swig_callbackOnKeyInputFocusGained = 0;
2458   swig_callbackOnKeyInputFocusLost = 0;
2459   swig_callbackGetNextKeyboardFocusableActor = 0;
2460   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2461   swig_callbackOnKeyboardEnter = 0;
2462   swig_callbackOnPinch = 0;
2463   swig_callbackOnPan = 0;
2464   swig_callbackOnTap = 0;
2465   swig_callbackOnLongPress = 0;
2466   swig_callbackSignalConnected = 0;
2467   swig_callbackSignalDisconnected = 0;
2468 }
2469
2470 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2471   swig_init_callbacks();
2472 }
2473
2474 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2475
2476 }
2477
2478
2479 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2480   unsigned int c_result = SwigValueInit< unsigned int >() ;
2481   unsigned int jresult = 0 ;
2482
2483   if (!swig_callbackGetNumberOfItems) {
2484     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2485   } else {
2486     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2487     c_result = (unsigned int)jresult;
2488   }
2489   return c_result;
2490 }
2491
2492 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2493   Dali::Actor c_result ;
2494   void * jresult = 0 ;
2495   unsigned int jitemId  ;
2496
2497   if (!swig_callbackNewItem) {
2498     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2499   } else {
2500     jitemId = itemId;
2501     jresult = (void *) swig_callbackNewItem(jitemId);
2502     if (!jresult) {
2503       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2504       return c_result;
2505     }
2506     c_result = *(Dali::Actor *)jresult;
2507   }
2508   return c_result;
2509 }
2510
2511 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2512   unsigned int jitemId  ;
2513   void * jactor  ;
2514
2515   if (!swig_callbackItemReleased) {
2516     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2517     return;
2518   } else {
2519     jitemId = itemId;
2520     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2521     swig_callbackItemReleased(jitemId, jactor);
2522   }
2523 }
2524
2525 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2526   return Dali::Toolkit::ItemFactory::GetExtension();
2527 }
2528
2529 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2530   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2531   swig_callbackNewItem = callbackNewItem;
2532   swig_callbackItemReleased = callbackItemReleased;
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_init_callbacks() {
2536   swig_callbackGetNumberOfItems = 0;
2537   swig_callbackNewItem = 0;
2538   swig_callbackItemReleased = 0;
2539 }
2540
2541 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2542   swig_init_callbacks();
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2546
2547 }
2548
2549
2550 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2551   Dali::Actor c_result ;
2552   void * jresult = 0 ;
2553   void * jcurrent  ;
2554   void * jproposed  ;
2555   int jdirection  ;
2556
2557   if (!swig_callbackGetNextFocusableActor) {
2558     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2559   } else {
2560     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2561     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2562     jdirection = (int)direction;
2563     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2564     if (!jresult) {
2565       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2566       return c_result;
2567     }
2568     c_result = *(Dali::Actor *)jresult;
2569   }
2570   return c_result;
2571 }
2572
2573 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2574   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2578   swig_callbackGetNextFocusableActor = 0;
2579 }
2580
2581
2582 #ifdef __cplusplus
2583 extern "C" {
2584 #endif
2585
2586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2587   void * jresult ;
2588   floatp *result = 0 ;
2589
2590   {
2591     try {
2592       result = (floatp *)new_floatp();
2593     } catch (std::out_of_range& e) {
2594       {
2595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2596       };
2597     } catch (std::exception& e) {
2598       {
2599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (DaliException e) {
2602       {
2603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2604       };
2605     } catch (...) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2608       };
2609     }
2610   }
2611   jresult = (void *)result;
2612   return jresult;
2613 }
2614
2615
2616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2617   floatp *arg1 = (floatp *) 0 ;
2618
2619   arg1 = (floatp *)jarg1;
2620   {
2621     try {
2622       delete_floatp(arg1);
2623     } catch (std::out_of_range& e) {
2624       {
2625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2626       };
2627     } catch (std::exception& e) {
2628       {
2629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (Dali::DaliException e) {
2632       {
2633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2634       };
2635     } catch (...) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2638       };
2639     }
2640   }
2641
2642 }
2643
2644
2645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2646   floatp *arg1 = (floatp *) 0 ;
2647   float arg2 ;
2648
2649   arg1 = (floatp *)jarg1;
2650   arg2 = (float)jarg2;
2651   {
2652     try {
2653       floatp_assign(arg1,arg2);
2654     } catch (std::out_of_range& e) {
2655       {
2656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2657       };
2658     } catch (std::exception& e) {
2659       {
2660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (Dali::DaliException e) {
2663       {
2664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2665       };
2666     } catch (...) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2669       };
2670     }
2671   }
2672
2673 }
2674
2675
2676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2677   float jresult ;
2678   floatp *arg1 = (floatp *) 0 ;
2679   float result;
2680
2681   arg1 = (floatp *)jarg1;
2682   {
2683     try {
2684       result = (float)floatp_value(arg1);
2685     } catch (std::out_of_range& e) {
2686       {
2687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2688       };
2689     } catch (std::exception& e) {
2690       {
2691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (DaliException e) {
2694       {
2695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2696       };
2697     } catch (...) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2700       };
2701     }
2702   }
2703   jresult = result;
2704   return jresult;
2705 }
2706
2707
2708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2709   void * jresult ;
2710   floatp *arg1 = (floatp *) 0 ;
2711   float *result = 0 ;
2712
2713   arg1 = (floatp *)jarg1;
2714   {
2715     try {
2716       result = (float *)floatp_cast(arg1);
2717     } catch (std::out_of_range& e) {
2718       {
2719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2720       };
2721     } catch (std::exception& e) {
2722       {
2723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (Dali::DaliException e) {
2726       {
2727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2728       };
2729     } catch (...) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2732       };
2733     }
2734   }
2735
2736   jresult = (void *)result;
2737   return jresult;
2738 }
2739
2740
2741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2742   void * jresult ;
2743   float *arg1 = (float *) 0 ;
2744   floatp *result = 0 ;
2745
2746   arg1 = (float *)jarg1;
2747   {
2748     try {
2749       result = (floatp *)floatp_frompointer(arg1);
2750     } catch (std::out_of_range& e) {
2751       {
2752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (std::exception& e) {
2755       {
2756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (Dali::DaliException e) {
2759       {
2760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2761       };
2762     } catch (...) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2765       };
2766     }
2767   }
2768
2769   jresult = (void *)result;
2770   return jresult;
2771 }
2772
2773
2774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2775   void * jresult ;
2776   intp *result = 0 ;
2777
2778   {
2779     try {
2780       result = (intp *)new_intp();
2781     } catch (std::out_of_range& e) {
2782       {
2783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2784       };
2785     } catch (std::exception& e) {
2786       {
2787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (Dali::DaliException e) {
2790       {
2791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2792       };
2793     } catch (...) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2796       };
2797     }
2798   }
2799
2800   jresult = (void *)result;
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2806   intp *arg1 = (intp *) 0 ;
2807
2808   arg1 = (intp *)jarg1;
2809   {
2810     try {
2811       delete_intp(arg1);
2812     } catch (std::out_of_range& e) {
2813       {
2814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2815       };
2816     } catch (std::exception& e) {
2817       {
2818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (Dali::DaliException e) {
2821       {
2822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2827       };
2828     }
2829   }
2830
2831 }
2832
2833
2834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2835   intp *arg1 = (intp *) 0 ;
2836   int arg2 ;
2837
2838   arg1 = (intp *)jarg1;
2839   arg2 = (int)jarg2;
2840   {
2841     try {
2842       intp_assign(arg1,arg2);
2843     } catch (std::out_of_range& e) {
2844       {
2845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2846       };
2847     } catch (std::exception& e) {
2848       {
2849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (Dali::DaliException e) {
2852       {
2853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2854       };
2855     } catch (...) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2858       };
2859     }
2860   }
2861
2862 }
2863
2864
2865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2866   int jresult ;
2867   intp *arg1 = (intp *) 0 ;
2868   int result;
2869
2870   arg1 = (intp *)jarg1;
2871   {
2872     try {
2873       result = (int)intp_value(arg1);
2874     } catch (std::out_of_range& e) {
2875       {
2876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2877       };
2878     } catch (std::exception& e) {
2879       {
2880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (Dali::DaliException e) {
2883       {
2884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2885       };
2886     } catch (...) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2889       };
2890     }
2891   }
2892
2893   jresult = result;
2894   return jresult;
2895 }
2896
2897
2898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2899   void * jresult ;
2900   intp *arg1 = (intp *) 0 ;
2901   int *result = 0 ;
2902
2903   arg1 = (intp *)jarg1;
2904   {
2905     try {
2906       result = (int *)intp_cast(arg1);
2907     } catch (std::out_of_range& e) {
2908       {
2909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2910       };
2911     } catch (std::exception& e) {
2912       {
2913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (Dali::DaliException e) {
2916       {
2917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2918       };
2919     } catch (...) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2922       };
2923     }
2924   }
2925
2926   jresult = (void *)result;
2927   return jresult;
2928 }
2929
2930
2931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2932   void * jresult ;
2933   int *arg1 = (int *) 0 ;
2934   intp *result = 0 ;
2935
2936   arg1 = (int *)jarg1;
2937   {
2938     try {
2939       result = (intp *)intp_frompointer(arg1);
2940     } catch (std::out_of_range& e) {
2941       {
2942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2943       };
2944     } catch (std::exception& e) {
2945       {
2946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (Dali::DaliException e) {
2949       {
2950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2951       };
2952     } catch (...) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2955       };
2956     }
2957   }
2958
2959   jresult = (void *)result;
2960   return jresult;
2961 }
2962
2963
2964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2965   void * jresult ;
2966   doublep *result = 0 ;
2967
2968   {
2969     try {
2970       result = (doublep *)new_doublep();
2971     } catch (std::out_of_range& e) {
2972       {
2973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2974       };
2975     } catch (std::exception& e) {
2976       {
2977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (Dali::DaliException e) {
2980       {
2981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2982       };
2983     } catch (...) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2986       };
2987     }
2988   }
2989
2990   jresult = (void *)result;
2991   return jresult;
2992 }
2993
2994
2995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2996   doublep *arg1 = (doublep *) 0 ;
2997
2998   arg1 = (doublep *)jarg1;
2999   {
3000     try {
3001       delete_doublep(arg1);
3002     } catch (std::out_of_range& e) {
3003       {
3004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3005       };
3006     } catch (std::exception& e) {
3007       {
3008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (Dali::DaliException e) {
3011       {
3012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3013       };
3014     } catch (...) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3017       };
3018     }
3019   }
3020
3021 }
3022
3023
3024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3025   doublep *arg1 = (doublep *) 0 ;
3026   double arg2 ;
3027
3028   arg1 = (doublep *)jarg1;
3029   arg2 = (double)jarg2;
3030   {
3031     try {
3032       doublep_assign(arg1,arg2);
3033     } catch (std::out_of_range& e) {
3034       {
3035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3036       };
3037     } catch (std::exception& e) {
3038       {
3039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (Dali::DaliException e) {
3042       {
3043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3044       };
3045     } catch (...) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3048       };
3049     }
3050   }
3051
3052 }
3053
3054
3055 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3056   double jresult ;
3057   doublep *arg1 = (doublep *) 0 ;
3058   double result;
3059
3060   arg1 = (doublep *)jarg1;
3061   {
3062     try {
3063       result = (double)doublep_value(arg1);
3064     } catch (std::out_of_range& e) {
3065       {
3066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3067       };
3068     } catch (std::exception& e) {
3069       {
3070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (Dali::DaliException e) {
3073       {
3074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3075       };
3076     } catch (...) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3079       };
3080     }
3081   }
3082
3083   jresult = result;
3084   return jresult;
3085 }
3086
3087
3088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3089   void * jresult ;
3090   doublep *arg1 = (doublep *) 0 ;
3091   double *result = 0 ;
3092
3093   arg1 = (doublep *)jarg1;
3094   {
3095     try {
3096       result = (double *)doublep_cast(arg1);
3097     } catch (std::out_of_range& e) {
3098       {
3099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3100       };
3101     } catch (std::exception& e) {
3102       {
3103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (Dali::DaliException e) {
3106       {
3107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3108       };
3109     } catch (...) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3112       };
3113     }
3114   }
3115
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3122   void * jresult ;
3123   double *arg1 = (double *) 0 ;
3124   doublep *result = 0 ;
3125
3126   arg1 = (double *)jarg1;
3127   {
3128     try {
3129       result = (doublep *)doublep_frompointer(arg1);
3130     } catch (std::out_of_range& e) {
3131       {
3132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (std::exception& e) {
3135       {
3136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (Dali::DaliException e) {
3139       {
3140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3141       };
3142     } catch (...) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3145       };
3146     }
3147   }
3148
3149   jresult = (void *)result;
3150   return jresult;
3151 }
3152
3153
3154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3155   void * jresult ;
3156   uintp *result = 0 ;
3157
3158   {
3159     try {
3160       result = (uintp *)new_uintp();
3161     } catch (std::out_of_range& e) {
3162       {
3163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3164       };
3165     } catch (std::exception& e) {
3166       {
3167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (Dali::DaliException e) {
3170       {
3171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3172       };
3173     } catch (...) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3176       };
3177     }
3178   }
3179
3180   jresult = (void *)result;
3181   return jresult;
3182 }
3183
3184
3185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3186   uintp *arg1 = (uintp *) 0 ;
3187
3188   arg1 = (uintp *)jarg1;
3189   {
3190     try {
3191       delete_uintp(arg1);
3192     } catch (std::out_of_range& e) {
3193       {
3194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3195       };
3196     } catch (std::exception& e) {
3197       {
3198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (Dali::DaliException e) {
3201       {
3202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3203       };
3204     } catch (...) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3207       };
3208     }
3209   }
3210
3211 }
3212
3213
3214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3215   uintp *arg1 = (uintp *) 0 ;
3216   unsigned int arg2 ;
3217
3218   arg1 = (uintp *)jarg1;
3219   arg2 = (unsigned int)jarg2;
3220   {
3221     try {
3222       uintp_assign(arg1,arg2);
3223     } catch (std::out_of_range& e) {
3224       {
3225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3226       };
3227     } catch (std::exception& e) {
3228       {
3229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (Dali::DaliException e) {
3232       {
3233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3234       };
3235     } catch (...) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3238       };
3239     }
3240   }
3241
3242 }
3243
3244
3245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3246   unsigned int jresult ;
3247   uintp *arg1 = (uintp *) 0 ;
3248   unsigned int result;
3249
3250   arg1 = (uintp *)jarg1;
3251   {
3252     try {
3253       result = (unsigned int)uintp_value(arg1);
3254     } catch (std::out_of_range& e) {
3255       {
3256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3257       };
3258     } catch (std::exception& e) {
3259       {
3260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (Dali::DaliException e) {
3263       {
3264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3265       };
3266     } catch (...) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3269       };
3270     }
3271   }
3272
3273   jresult = result;
3274   return jresult;
3275 }
3276
3277
3278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3279   void * jresult ;
3280   uintp *arg1 = (uintp *) 0 ;
3281   unsigned int *result = 0 ;
3282
3283   arg1 = (uintp *)jarg1;
3284   {
3285     try {
3286       result = (unsigned int *)uintp_cast(arg1);
3287     } catch (std::out_of_range& e) {
3288       {
3289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3290       };
3291     } catch (std::exception& e) {
3292       {
3293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (Dali::DaliException e) {
3296       {
3297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3298       };
3299     } catch (...) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3302       };
3303     }
3304   }
3305
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3312   void * jresult ;
3313   unsigned int *arg1 = (unsigned int *) 0 ;
3314   uintp *result = 0 ;
3315
3316   arg1 = (unsigned int *)jarg1;
3317   {
3318     try {
3319       result = (uintp *)uintp_frompointer(arg1);
3320     } catch (std::out_of_range& e) {
3321       {
3322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3323       };
3324     } catch (std::exception& e) {
3325       {
3326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (Dali::DaliException e) {
3329       {
3330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3331       };
3332     } catch (...) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3335       };
3336     }
3337   }
3338
3339   jresult = (void *)result;
3340   return jresult;
3341 }
3342
3343
3344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3345   void * jresult ;
3346   ushortp *result = 0 ;
3347
3348   {
3349     try {
3350       result = (ushortp *)new_ushortp();
3351     } catch (std::out_of_range& e) {
3352       {
3353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3354       };
3355     } catch (std::exception& e) {
3356       {
3357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (Dali::DaliException e) {
3360       {
3361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3362       };
3363     } catch (...) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3366       };
3367     }
3368   }
3369
3370   jresult = (void *)result;
3371   return jresult;
3372 }
3373
3374
3375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3376   ushortp *arg1 = (ushortp *) 0 ;
3377
3378   arg1 = (ushortp *)jarg1;
3379   {
3380     try {
3381       delete_ushortp(arg1);
3382     } catch (std::out_of_range& e) {
3383       {
3384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3385       };
3386     } catch (std::exception& e) {
3387       {
3388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (Dali::DaliException e) {
3391       {
3392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3393       };
3394     } catch (...) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3397       };
3398     }
3399   }
3400
3401 }
3402
3403
3404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3405   ushortp *arg1 = (ushortp *) 0 ;
3406   unsigned short arg2 ;
3407
3408   arg1 = (ushortp *)jarg1;
3409   arg2 = (unsigned short)jarg2;
3410   {
3411     try {
3412       ushortp_assign(arg1,arg2);
3413     } catch (std::out_of_range& e) {
3414       {
3415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3416       };
3417     } catch (std::exception& e) {
3418       {
3419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (Dali::DaliException e) {
3422       {
3423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3424       };
3425     } catch (...) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3428       };
3429     }
3430   }
3431
3432 }
3433
3434
3435 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3436   unsigned short jresult ;
3437   ushortp *arg1 = (ushortp *) 0 ;
3438   unsigned short result;
3439
3440   arg1 = (ushortp *)jarg1;
3441   {
3442     try {
3443       result = (unsigned short)ushortp_value(arg1);
3444     } catch (std::out_of_range& e) {
3445       {
3446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3447       };
3448     } catch (std::exception& e) {
3449       {
3450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (Dali::DaliException e) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3455       };
3456     } catch (...) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3459       };
3460     }
3461   }
3462
3463   jresult = result;
3464   return jresult;
3465 }
3466
3467
3468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3469   void * jresult ;
3470   ushortp *arg1 = (ushortp *) 0 ;
3471   unsigned short *result = 0 ;
3472
3473   arg1 = (ushortp *)jarg1;
3474   {
3475     try {
3476       result = (unsigned short *)ushortp_cast(arg1);
3477     } catch (std::out_of_range& e) {
3478       {
3479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3480       };
3481     } catch (std::exception& e) {
3482       {
3483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (Dali::DaliException e) {
3486       {
3487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3488       };
3489     } catch (...) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3492       };
3493     }
3494   }
3495
3496   jresult = (void *)result;
3497   return jresult;
3498 }
3499
3500
3501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3502   void * jresult ;
3503   unsigned short *arg1 = (unsigned short *) 0 ;
3504   ushortp *result = 0 ;
3505
3506   arg1 = (unsigned short *)jarg1;
3507   {
3508     try {
3509       result = (ushortp *)ushortp_frompointer(arg1);
3510     } catch (std::out_of_range& e) {
3511       {
3512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3513       };
3514     } catch (std::exception& e) {
3515       {
3516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (Dali::DaliException e) {
3519       {
3520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3521       };
3522     } catch (...) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3525       };
3526     }
3527   }
3528
3529   jresult = (void *)result;
3530   return jresult;
3531 }
3532
3533
3534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3535   unsigned int jresult ;
3536   int arg1 ;
3537   unsigned int result;
3538
3539   arg1 = (int)jarg1;
3540   {
3541     try {
3542       result = (unsigned int)int_to_uint(arg1);
3543     } catch (std::out_of_range& e) {
3544       {
3545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3546       };
3547     } catch (std::exception& e) {
3548       {
3549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (Dali::DaliException e) {
3552       {
3553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3554       };
3555     } catch (...) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3558       };
3559     }
3560   }
3561
3562   jresult = result;
3563   return jresult;
3564 }
3565
3566
3567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3568   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3569
3570   arg1 = (Dali::RefObject *)jarg1;
3571   {
3572     try {
3573       (arg1)->Reference();
3574     } catch (std::out_of_range& e) {
3575       {
3576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3577       };
3578     } catch (std::exception& e) {
3579       {
3580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (Dali::DaliException e) {
3583       {
3584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3585       };
3586     } catch (...) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3589       };
3590     }
3591   }
3592
3593 }
3594
3595
3596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3597   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3598
3599   arg1 = (Dali::RefObject *)jarg1;
3600   {
3601     try {
3602       (arg1)->Unreference();
3603     } catch (std::out_of_range& e) {
3604       {
3605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3606       };
3607     } catch (std::exception& e) {
3608       {
3609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (Dali::DaliException e) {
3612       {
3613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3614       };
3615     } catch (...) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3618       };
3619     }
3620   }
3621
3622 }
3623
3624
3625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3626   int jresult ;
3627   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3628   int result;
3629
3630   arg1 = (Dali::RefObject *)jarg1;
3631   {
3632     try {
3633       result = (int)(arg1)->ReferenceCount();
3634     } catch (std::out_of_range& e) {
3635       {
3636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3637       };
3638     } catch (std::exception& e) {
3639       {
3640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (Dali::DaliException e) {
3643       {
3644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3645       };
3646     } catch (...) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3649       };
3650     }
3651   }
3652
3653   jresult = result;
3654   return jresult;
3655 }
3656
3657
3658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3659   void * jresult ;
3660   Dali::Any *result = 0 ;
3661
3662   {
3663     try {
3664       result = (Dali::Any *)new Dali::Any();
3665     } catch (std::out_of_range& e) {
3666       {
3667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3668       };
3669     } catch (std::exception& e) {
3670       {
3671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (Dali::DaliException e) {
3674       {
3675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3676       };
3677     } catch (...) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3680       };
3681     }
3682   }
3683
3684   jresult = (void *)result;
3685   return jresult;
3686 }
3687
3688
3689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3690   Dali::Any *arg1 = (Dali::Any *) 0 ;
3691
3692   arg1 = (Dali::Any *)jarg1;
3693   {
3694     try {
3695       delete arg1;
3696     } catch (std::out_of_range& e) {
3697       {
3698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3699       };
3700     } catch (std::exception& e) {
3701       {
3702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (Dali::DaliException e) {
3705       {
3706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3707       };
3708     } catch (...) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3711       };
3712     }
3713   }
3714
3715 }
3716
3717
3718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3719   char *arg1 = (char *) 0 ;
3720
3721   arg1 = (char *)jarg1;
3722   {
3723     try {
3724       Dali::Any::AssertAlways((char const *)arg1);
3725     } catch (std::out_of_range& e) {
3726       {
3727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3728       };
3729     } catch (std::exception& e) {
3730       {
3731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (Dali::DaliException e) {
3734       {
3735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3736       };
3737     } catch (...) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3740       };
3741     }
3742   }
3743
3744 }
3745
3746
3747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3748   void * jresult ;
3749   Dali::Any *arg1 = 0 ;
3750   Dali::Any *result = 0 ;
3751
3752   arg1 = (Dali::Any *)jarg1;
3753   if (!arg1) {
3754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3755     return 0;
3756   }
3757   {
3758     try {
3759       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3760     } catch (std::out_of_range& e) {
3761       {
3762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3763       };
3764     } catch (std::exception& e) {
3765       {
3766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (Dali::DaliException e) {
3769       {
3770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3771       };
3772     } catch (...) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3775       };
3776     }
3777   }
3778
3779   jresult = (void *)result;
3780   return jresult;
3781 }
3782
3783
3784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3785   void * jresult ;
3786   Dali::Any *arg1 = (Dali::Any *) 0 ;
3787   Dali::Any *arg2 = 0 ;
3788   Dali::Any *result = 0 ;
3789
3790   arg1 = (Dali::Any *)jarg1;
3791   arg2 = (Dali::Any *)jarg2;
3792   if (!arg2) {
3793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3794     return 0;
3795   }
3796   {
3797     try {
3798       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3799     } catch (std::out_of_range& e) {
3800       {
3801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3802       };
3803     } catch (std::exception& e) {
3804       {
3805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (Dali::DaliException e) {
3808       {
3809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3810       };
3811     } catch (...) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3814       };
3815     }
3816   }
3817
3818   jresult = (void *)result;
3819   return jresult;
3820 }
3821
3822
3823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3824   void * jresult ;
3825   Dali::Any *arg1 = (Dali::Any *) 0 ;
3826   std::type_info *result = 0 ;
3827
3828   arg1 = (Dali::Any *)jarg1;
3829   {
3830     try {
3831       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3832     } catch (std::out_of_range& e) {
3833       {
3834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3835       };
3836     } catch (std::exception& e) {
3837       {
3838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (Dali::DaliException e) {
3841       {
3842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3843       };
3844     } catch (...) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3847       };
3848     }
3849   }
3850
3851   jresult = (void *)result;
3852   return jresult;
3853 }
3854
3855
3856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3857   unsigned int jresult ;
3858   Dali::Any *arg1 = (Dali::Any *) 0 ;
3859   bool result;
3860
3861   arg1 = (Dali::Any *)jarg1;
3862   {
3863     try {
3864       result = (bool)((Dali::Any const *)arg1)->Empty();
3865     } catch (std::out_of_range& e) {
3866       {
3867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3868       };
3869     } catch (std::exception& e) {
3870       {
3871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (Dali::DaliException e) {
3874       {
3875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883
3884   jresult = result;
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3890   void * jresult ;
3891   std::type_info *arg1 = 0 ;
3892   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3893   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3894   Dali::Any::AnyContainerBase *result = 0 ;
3895
3896   arg1 = (std::type_info *)jarg1;
3897   if (!arg1) {
3898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3899     return 0;
3900   }
3901   arg2 = (Dali::Any::CloneFunc)jarg2;
3902   arg3 = (Dali::Any::DeleteFunc)jarg3;
3903   {
3904     try {
3905       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3906     } catch (std::out_of_range& e) {
3907       {
3908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3909       };
3910     } catch (std::exception& e) {
3911       {
3912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (Dali::DaliException e) {
3915       {
3916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3917       };
3918     } catch (...) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3921       };
3922     }
3923   }
3924
3925   jresult = (void *)result;
3926   return jresult;
3927 }
3928
3929
3930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3931   void * jresult ;
3932   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3933   std::type_info *result = 0 ;
3934
3935   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3936   {
3937     try {
3938       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3939     } catch (std::out_of_range& e) {
3940       {
3941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3942       };
3943     } catch (std::exception& e) {
3944       {
3945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (Dali::DaliException e) {
3948       {
3949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3950       };
3951     } catch (...) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3954       };
3955     }
3956   }
3957
3958   jresult = (void *)result;
3959   return jresult;
3960 }
3961
3962
3963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3964   void * jresult ;
3965   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3966   ::std::type_info *result = 0 ;
3967
3968   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3969   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3970   jresult = (void *)result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3976   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3977   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   arg2 = (Dali::Any::CloneFunc)jarg2;
3981   if (arg1) (arg1)->mCloneFunc = arg2;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3986   void * jresult ;
3987   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3988   Dali::Any::CloneFunc result;
3989
3990   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3991   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3992   jresult = (void *)result;
3993   return jresult;
3994 }
3995
3996
3997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3998   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3999   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4000
4001   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4002   arg2 = (Dali::Any::DeleteFunc)jarg2;
4003   if (arg1) (arg1)->mDeleteFunc = arg2;
4004 }
4005
4006
4007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4008   void * jresult ;
4009   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4010   Dali::Any::DeleteFunc result;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4014   jresult = (void *)result;
4015   return jresult;
4016 }
4017
4018
4019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4020   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4021
4022   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4023   {
4024     try {
4025       delete arg1;
4026     } catch (std::out_of_range& e) {
4027       {
4028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4029       };
4030     } catch (std::exception& e) {
4031       {
4032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (Dali::DaliException e) {
4035       {
4036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4037       };
4038     } catch (...) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4041       };
4042     }
4043   }
4044
4045 }
4046
4047
4048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4049   Dali::Any *arg1 = (Dali::Any *) 0 ;
4050   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4051
4052   arg1 = (Dali::Any *)jarg1;
4053   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4054   if (arg1) (arg1)->mContainer = arg2;
4055 }
4056
4057
4058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4059   void * jresult ;
4060   Dali::Any *arg1 = (Dali::Any *) 0 ;
4061   Dali::Any::AnyContainerBase *result = 0 ;
4062
4063   arg1 = (Dali::Any *)jarg1;
4064   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4065   jresult = (void *)result;
4066   return jresult;
4067 }
4068
4069
4070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4071   char *arg1 = (char *) 0 ;
4072   char *arg2 = (char *) 0 ;
4073
4074   arg1 = (char *)jarg1;
4075   arg2 = (char *)jarg2;
4076   {
4077     try {
4078       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4079     } catch (std::out_of_range& e) {
4080       {
4081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4082       };
4083     } catch (std::exception& e) {
4084       {
4085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (Dali::DaliException e) {
4088       {
4089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4090       };
4091     } catch (...) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4094       };
4095     }
4096   }
4097
4098 }
4099
4100
4101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4102   void * jresult ;
4103   char *arg1 = (char *) 0 ;
4104   char *arg2 = (char *) 0 ;
4105   Dali::DaliException *result = 0 ;
4106
4107   arg1 = (char *)jarg1;
4108   arg2 = (char *)jarg2;
4109   {
4110     try {
4111       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4112     } catch (std::out_of_range& e) {
4113       {
4114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (std::exception& e) {
4117       {
4118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (Dali::DaliException e) {
4121       {
4122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4123       };
4124     } catch (...) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4127       };
4128     }
4129   }
4130
4131   jresult = (void *)result;
4132   return jresult;
4133 }
4134
4135
4136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4137   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4138   std::string arg2 = std::string(jarg2);
4139
4140   arg1 = (Dali::DaliException *)jarg1;
4141   {
4142     if (!arg2.empty()) {
4143       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4144     } else {
4145       arg1->location = 0;
4146     }
4147   }
4148 }
4149
4150 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4151   char * jresult ;
4152   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4153   char *result = 0 ;
4154
4155   arg1 = (Dali::DaliException *)jarg1;
4156   result = (char *) ((arg1)->location);
4157   jresult = SWIG_csharp_string_callback((const char *)result);
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164   std::string arg2 = std::string(jarg2);
4165
4166   arg1 = (Dali::DaliException *)jarg1;
4167   {
4168     if (!arg2.empty()) {
4169       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4170     } else {
4171       arg1->condition = 0;
4172     }
4173   }
4174 }
4175
4176
4177 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4178   char * jresult ;
4179   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4180   char *result = 0 ;
4181
4182   arg1 = (Dali::DaliException *)jarg1;
4183   result = (char *) ((arg1)->condition);
4184   jresult = SWIG_csharp_string_callback((const char *)result);
4185   return jresult;
4186 }
4187
4188
4189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4190   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4191
4192   arg1 = (Dali::DaliException *)jarg1;
4193   {
4194     try {
4195       delete arg1;
4196     } catch (std::out_of_range& e) {
4197       {
4198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4199       };
4200     } catch (std::exception& e) {
4201       {
4202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (Dali::DaliException e) {
4205       {
4206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4207       };
4208     } catch (...) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4211       };
4212     }
4213   }
4214
4215 }
4216
4217
4218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4219   void * jresult ;
4220   Dali::Vector2 *result = 0 ;
4221
4222   {
4223     try {
4224       result = (Dali::Vector2 *)new Dali::Vector2();
4225     } catch (std::out_of_range& e) {
4226       {
4227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4228       };
4229     } catch (std::exception& e) {
4230       {
4231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (Dali::DaliException e) {
4234       {
4235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4236       };
4237     } catch (...) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4240       };
4241     }
4242   }
4243
4244   jresult = (void *)result;
4245   return jresult;
4246 }
4247
4248
4249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4250   void * jresult ;
4251   float arg1 ;
4252   float arg2 ;
4253   Dali::Vector2 *result = 0 ;
4254
4255   arg1 = (float)jarg1;
4256   arg2 = (float)jarg2;
4257   {
4258     try {
4259       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4260     } catch (std::out_of_range& e) {
4261       {
4262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (std::exception& e) {
4265       {
4266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (Dali::DaliException e) {
4269       {
4270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4271       };
4272     } catch (...) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4275       };
4276     }
4277   }
4278
4279   jresult = (void *)result;
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4285   void * jresult ;
4286   float *arg1 = (float *) 0 ;
4287   Dali::Vector2 *result = 0 ;
4288
4289   arg1 = jarg1;
4290   {
4291     try {
4292       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4293     } catch (std::out_of_range& e) {
4294       {
4295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4296       };
4297     } catch (std::exception& e) {
4298       {
4299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (Dali::DaliException e) {
4302       {
4303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4304       };
4305     } catch (...) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4308       };
4309     }
4310   }
4311
4312   jresult = (void *)result;
4313
4314
4315   return jresult;
4316 }
4317
4318
4319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4320   void * jresult ;
4321   Dali::Vector3 *arg1 = 0 ;
4322   Dali::Vector2 *result = 0 ;
4323
4324   arg1 = (Dali::Vector3 *)jarg1;
4325   if (!arg1) {
4326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4327     return 0;
4328   }
4329   {
4330     try {
4331       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4332     } catch (std::out_of_range& e) {
4333       {
4334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (std::exception& e) {
4337       {
4338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (Dali::DaliException e) {
4341       {
4342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4343       };
4344     } catch (...) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4347       };
4348     }
4349   }
4350
4351   jresult = (void *)result;
4352   return jresult;
4353 }
4354
4355
4356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4357   void * jresult ;
4358   Dali::Vector4 *arg1 = 0 ;
4359   Dali::Vector2 *result = 0 ;
4360
4361   arg1 = (Dali::Vector4 *)jarg1;
4362   if (!arg1) {
4363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4364     return 0;
4365   }
4366   {
4367     try {
4368       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4369     } catch (std::out_of_range& e) {
4370       {
4371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4372       };
4373     } catch (std::exception& e) {
4374       {
4375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (Dali::DaliException e) {
4378       {
4379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4380       };
4381     } catch (...) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4384       };
4385     }
4386   }
4387
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4394   void * jresult ;
4395   Dali::Vector2 *result = 0 ;
4396
4397   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4398   jresult = (void *)result;
4399   return jresult;
4400 }
4401
4402
4403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4404   void * jresult ;
4405   Dali::Vector2 *result = 0 ;
4406
4407   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4408   jresult = (void *)result;
4409   return jresult;
4410 }
4411
4412
4413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4414   void * jresult ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4418   jresult = (void *)result;
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4424   void * jresult ;
4425   Dali::Vector2 *result = 0 ;
4426
4427   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4428   jresult = (void *)result;
4429   return jresult;
4430 }
4431
4432
4433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4434   void * jresult ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4438   jresult = (void *)result;
4439   return jresult;
4440 }
4441
4442
4443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4444   void * jresult ;
4445   Dali::Vector2 *result = 0 ;
4446
4447   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4448   jresult = (void *)result;
4449   return jresult;
4450 }
4451
4452
4453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4454   void * jresult ;
4455   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4456   float *arg2 = (float *) 0 ;
4457   Dali::Vector2 *result = 0 ;
4458
4459   arg1 = (Dali::Vector2 *)jarg1;
4460   arg2 = jarg2;
4461   {
4462     try {
4463       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4464     } catch (std::out_of_range& e) {
4465       {
4466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4467       };
4468     } catch (std::exception& e) {
4469       {
4470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (Dali::DaliException e) {
4473       {
4474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482
4483   jresult = (void *)result;
4484
4485
4486   return jresult;
4487 }
4488
4489
4490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4491   void * jresult ;
4492   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4493   Dali::Vector3 *arg2 = 0 ;
4494   Dali::Vector2 *result = 0 ;
4495
4496   arg1 = (Dali::Vector2 *)jarg1;
4497   arg2 = (Dali::Vector3 *)jarg2;
4498   if (!arg2) {
4499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4500     return 0;
4501   }
4502   {
4503     try {
4504       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4505     } catch (std::out_of_range& e) {
4506       {
4507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4508       };
4509     } catch (std::exception& e) {
4510       {
4511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (Dali::DaliException e) {
4514       {
4515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4516       };
4517     } catch (...) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4520       };
4521     }
4522   }
4523
4524   jresult = (void *)result;
4525   return jresult;
4526 }
4527
4528
4529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4530   void * jresult ;
4531   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4532   Dali::Vector4 *arg2 = 0 ;
4533   Dali::Vector2 *result = 0 ;
4534
4535   arg1 = (Dali::Vector2 *)jarg1;
4536   arg2 = (Dali::Vector4 *)jarg2;
4537   if (!arg2) {
4538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4539     return 0;
4540   }
4541   {
4542     try {
4543       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4544     } catch (std::out_of_range& e) {
4545       {
4546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (std::exception& e) {
4549       {
4550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (Dali::DaliException e) {
4553       {
4554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4555       };
4556     } catch (...) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4559       };
4560     }
4561   }
4562
4563   jresult = (void *)result;
4564   return jresult;
4565 }
4566
4567
4568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4569   void * jresult ;
4570   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4571   Dali::Vector2 *arg2 = 0 ;
4572   Dali::Vector2 result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   arg2 = (Dali::Vector2 *)jarg2;
4576   if (!arg2) {
4577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4578     return 0;
4579   }
4580   {
4581     try {
4582       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4583     } catch (std::out_of_range& e) {
4584       {
4585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (std::exception& e) {
4588       {
4589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (Dali::DaliException e) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4594       };
4595     } catch (...) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4598       };
4599     }
4600   }
4601
4602   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4603   return jresult;
4604 }
4605
4606
4607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4608   void * jresult ;
4609   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4610   Dali::Vector2 *arg2 = 0 ;
4611   Dali::Vector2 *result = 0 ;
4612
4613   arg1 = (Dali::Vector2 *)jarg1;
4614   arg2 = (Dali::Vector2 *)jarg2;
4615   if (!arg2) {
4616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4617     return 0;
4618   }
4619   {
4620     try {
4621       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4622     } catch (std::out_of_range& e) {
4623       {
4624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4625       };
4626     } catch (std::exception& e) {
4627       {
4628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (Dali::DaliException e) {
4631       {
4632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4633       };
4634     } catch (...) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4637       };
4638     }
4639   }
4640
4641   jresult = (void *)result;
4642   return jresult;
4643 }
4644
4645
4646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4647   void * jresult ;
4648   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4649   Dali::Vector2 *arg2 = 0 ;
4650   Dali::Vector2 result;
4651
4652   arg1 = (Dali::Vector2 *)jarg1;
4653   arg2 = (Dali::Vector2 *)jarg2;
4654   if (!arg2) {
4655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4656     return 0;
4657   }
4658   {
4659     try {
4660       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4661     } catch (std::out_of_range& e) {
4662       {
4663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4664       };
4665     } catch (std::exception& e) {
4666       {
4667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (Dali::DaliException e) {
4670       {
4671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4672       };
4673     } catch (...) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4676       };
4677     }
4678   }
4679
4680   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4681   return jresult;
4682 }
4683
4684
4685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4686   void * jresult ;
4687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4688   Dali::Vector2 *arg2 = 0 ;
4689   Dali::Vector2 *result = 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   arg2 = (Dali::Vector2 *)jarg2;
4693   if (!arg2) {
4694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4695     return 0;
4696   }
4697   {
4698     try {
4699       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4700     } catch (std::out_of_range& e) {
4701       {
4702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (std::exception& e) {
4705       {
4706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (Dali::DaliException e) {
4709       {
4710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4711       };
4712     } catch (...) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4715       };
4716     }
4717   }
4718
4719   jresult = (void *)result;
4720   return jresult;
4721 }
4722
4723
4724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4725   void * jresult ;
4726   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4727   Dali::Vector2 *arg2 = 0 ;
4728   Dali::Vector2 result;
4729
4730   arg1 = (Dali::Vector2 *)jarg1;
4731   arg2 = (Dali::Vector2 *)jarg2;
4732   if (!arg2) {
4733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4734     return 0;
4735   }
4736   {
4737     try {
4738       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4739     } catch (std::out_of_range& e) {
4740       {
4741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4742       };
4743     } catch (std::exception& e) {
4744       {
4745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (Dali::DaliException e) {
4748       {
4749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4750       };
4751     } catch (...) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4754       };
4755     }
4756   }
4757
4758   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4759   return jresult;
4760 }
4761
4762
4763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4764   void * jresult ;
4765   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4766   float arg2 ;
4767   Dali::Vector2 result;
4768
4769   arg1 = (Dali::Vector2 *)jarg1;
4770   arg2 = (float)jarg2;
4771   {
4772     try {
4773       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4774     } catch (std::out_of_range& e) {
4775       {
4776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4777       };
4778     } catch (std::exception& e) {
4779       {
4780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (Dali::DaliException e) {
4783       {
4784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4785       };
4786     } catch (...) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4789       };
4790     }
4791   }
4792
4793   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4794   return jresult;
4795 }
4796
4797
4798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4799   void * jresult ;
4800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4801   Dali::Vector2 *arg2 = 0 ;
4802   Dali::Vector2 *result = 0 ;
4803
4804   arg1 = (Dali::Vector2 *)jarg1;
4805   arg2 = (Dali::Vector2 *)jarg2;
4806   if (!arg2) {
4807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4808     return 0;
4809   }
4810   {
4811     try {
4812       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4813     } catch (std::out_of_range& e) {
4814       {
4815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4816       };
4817     } catch (std::exception& e) {
4818       {
4819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (Dali::DaliException e) {
4822       {
4823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4824       };
4825     } catch (...) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4828       };
4829     }
4830   }
4831
4832   jresult = (void *)result;
4833   return jresult;
4834 }
4835
4836
4837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4838   void * jresult ;
4839   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4840   float arg2 ;
4841   Dali::Vector2 *result = 0 ;
4842
4843   arg1 = (Dali::Vector2 *)jarg1;
4844   arg2 = (float)jarg2;
4845   {
4846     try {
4847       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4848     } catch (std::out_of_range& e) {
4849       {
4850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4851       };
4852     } catch (std::exception& e) {
4853       {
4854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (Dali::DaliException e) {
4857       {
4858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4859       };
4860     } catch (...) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4863       };
4864     }
4865   }
4866
4867   jresult = (void *)result;
4868   return jresult;
4869 }
4870
4871
4872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4873   void * jresult ;
4874   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4875   Dali::Vector2 *arg2 = 0 ;
4876   Dali::Vector2 result;
4877
4878   arg1 = (Dali::Vector2 *)jarg1;
4879   arg2 = (Dali::Vector2 *)jarg2;
4880   if (!arg2) {
4881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4882     return 0;
4883   }
4884   {
4885     try {
4886       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4887     } catch (std::out_of_range& e) {
4888       {
4889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4890       };
4891     } catch (std::exception& e) {
4892       {
4893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (Dali::DaliException e) {
4896       {
4897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4898       };
4899     } catch (...) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4902       };
4903     }
4904   }
4905
4906   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4907   return jresult;
4908 }
4909
4910
4911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4912   void * jresult ;
4913   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4914   float arg2 ;
4915   Dali::Vector2 result;
4916
4917   arg1 = (Dali::Vector2 *)jarg1;
4918   arg2 = (float)jarg2;
4919   {
4920     try {
4921       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4922     } catch (std::out_of_range& e) {
4923       {
4924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4925       };
4926     } catch (std::exception& e) {
4927       {
4928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (Dali::DaliException e) {
4931       {
4932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4933       };
4934     } catch (...) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4937       };
4938     }
4939   }
4940
4941   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4947   void * jresult ;
4948   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4949   Dali::Vector2 *arg2 = 0 ;
4950   Dali::Vector2 *result = 0 ;
4951
4952   arg1 = (Dali::Vector2 *)jarg1;
4953   arg2 = (Dali::Vector2 *)jarg2;
4954   if (!arg2) {
4955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4956     return 0;
4957   }
4958   {
4959     try {
4960       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4961     } catch (std::out_of_range& e) {
4962       {
4963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4964       };
4965     } catch (std::exception& e) {
4966       {
4967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (Dali::DaliException e) {
4970       {
4971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4972       };
4973     } catch (...) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4976       };
4977     }
4978   }
4979
4980   jresult = (void *)result;
4981   return jresult;
4982 }
4983
4984
4985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4986   void * jresult ;
4987   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4988   float arg2 ;
4989   Dali::Vector2 *result = 0 ;
4990
4991   arg1 = (Dali::Vector2 *)jarg1;
4992   arg2 = (float)jarg2;
4993   {
4994     try {
4995       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4996     } catch (std::out_of_range& e) {
4997       {
4998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4999       };
5000     } catch (std::exception& e) {
5001       {
5002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (Dali::DaliException e) {
5005       {
5006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5007       };
5008     } catch (...) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5011       };
5012     }
5013   }
5014
5015   jresult = (void *)result;
5016   return jresult;
5017 }
5018
5019
5020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5021   void * jresult ;
5022   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5023   Dali::Vector2 result;
5024
5025   arg1 = (Dali::Vector2 *)jarg1;
5026   {
5027     try {
5028       result = ((Dali::Vector2 const *)arg1)->operator -();
5029     } catch (std::out_of_range& e) {
5030       {
5031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (std::exception& e) {
5034       {
5035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (Dali::DaliException e) {
5038       {
5039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5040       };
5041     } catch (...) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5044       };
5045     }
5046   }
5047
5048   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5049   return jresult;
5050 }
5051
5052
5053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5054   unsigned int jresult ;
5055   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5056   Dali::Vector2 *arg2 = 0 ;
5057   bool result;
5058
5059   arg1 = (Dali::Vector2 *)jarg1;
5060   arg2 = (Dali::Vector2 *)jarg2;
5061   if (!arg2) {
5062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5063     return 0;
5064   }
5065   {
5066     try {
5067       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5068     } catch (std::out_of_range& e) {
5069       {
5070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (std::exception& e) {
5073       {
5074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (Dali::DaliException e) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5079       };
5080     } catch (...) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5083       };
5084     }
5085   }
5086
5087   jresult = result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5093   unsigned int jresult ;
5094   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5095   Dali::Vector2 *arg2 = 0 ;
5096   bool result;
5097
5098   arg1 = (Dali::Vector2 *)jarg1;
5099   arg2 = (Dali::Vector2 *)jarg2;
5100   if (!arg2) {
5101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5102     return 0;
5103   }
5104   {
5105     try {
5106       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5107     } catch (std::out_of_range& e) {
5108       {
5109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5110       };
5111     } catch (std::exception& e) {
5112       {
5113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (Dali::DaliException e) {
5116       {
5117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5118       };
5119     } catch (...) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5122       };
5123     }
5124   }
5125
5126   jresult = result;
5127   return jresult;
5128 }
5129
5130
5131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5132   float jresult ;
5133   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5134   unsigned int arg2 ;
5135   float *result = 0 ;
5136
5137   arg1 = (Dali::Vector2 *)jarg1;
5138   arg2 = (unsigned int)jarg2;
5139   {
5140     try {
5141       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5142     } catch (std::out_of_range& e) {
5143       {
5144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5145       };
5146     } catch (std::exception& e) {
5147       {
5148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (Dali::DaliException e) {
5151       {
5152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5153       };
5154     } catch (...) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5157       };
5158     }
5159   }
5160
5161   jresult = *result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5167   float jresult ;
5168   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5169   float result;
5170
5171   arg1 = (Dali::Vector2 *)jarg1;
5172   {
5173     try {
5174       result = (float)((Dali::Vector2 const *)arg1)->Length();
5175     } catch (std::out_of_range& e) {
5176       {
5177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5178       };
5179     } catch (std::exception& e) {
5180       {
5181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (Dali::DaliException e) {
5184       {
5185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5186       };
5187     } catch (...) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5190       };
5191     }
5192   }
5193
5194   jresult = result;
5195   return jresult;
5196 }
5197
5198
5199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5200   float jresult ;
5201   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5202   float result;
5203
5204   arg1 = (Dali::Vector2 *)jarg1;
5205   {
5206     try {
5207       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5208     } catch (std::out_of_range& e) {
5209       {
5210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5211       };
5212     } catch (std::exception& e) {
5213       {
5214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (Dali::DaliException e) {
5217       {
5218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5219       };
5220     } catch (...) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5223       };
5224     }
5225   }
5226
5227   jresult = result;
5228   return jresult;
5229 }
5230
5231
5232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5234
5235   arg1 = (Dali::Vector2 *)jarg1;
5236   {
5237     try {
5238       (arg1)->Normalize();
5239     } catch (std::out_of_range& e) {
5240       {
5241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5242       };
5243     } catch (std::exception& e) {
5244       {
5245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (Dali::DaliException e) {
5248       {
5249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5250       };
5251     } catch (...) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5254       };
5255     }
5256   }
5257
5258 }
5259
5260
5261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5262   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5263   Dali::Vector2 *arg2 = 0 ;
5264   Dali::Vector2 *arg3 = 0 ;
5265
5266   arg1 = (Dali::Vector2 *)jarg1;
5267   arg2 = (Dali::Vector2 *)jarg2;
5268   if (!arg2) {
5269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5270     return ;
5271   }
5272   arg3 = (Dali::Vector2 *)jarg3;
5273   if (!arg3) {
5274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5275     return ;
5276   }
5277   {
5278     try {
5279       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5280     } catch (std::out_of_range& e) {
5281       {
5282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5283       };
5284     } catch (std::exception& e) {
5285       {
5286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (Dali::DaliException e) {
5289       {
5290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5291       };
5292     } catch (...) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5295       };
5296     }
5297   }
5298
5299 }
5300
5301
5302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5303   void * jresult ;
5304   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5305   float *result = 0 ;
5306
5307   arg1 = (Dali::Vector2 *)jarg1;
5308   {
5309     try {
5310       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5311     } catch (std::out_of_range& e) {
5312       {
5313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5314       };
5315     } catch (std::exception& e) {
5316       {
5317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (Dali::DaliException e) {
5320       {
5321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5322       };
5323     } catch (...) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5326       };
5327     }
5328   }
5329
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5336   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5337   float arg2 ;
5338
5339   arg1 = (Dali::Vector2 *)jarg1;
5340   arg2 = (float)jarg2;
5341   if (arg1) (arg1)->x = arg2;
5342 }
5343
5344
5345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5346   float jresult ;
5347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5348   float result;
5349
5350   arg1 = (Dali::Vector2 *)jarg1;
5351   result = (float) ((arg1)->x);
5352   jresult = result;
5353   return jresult;
5354 }
5355
5356
5357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5359   float arg2 ;
5360
5361   arg1 = (Dali::Vector2 *)jarg1;
5362   arg2 = (float)jarg2;
5363   if (arg1) (arg1)->width = arg2;
5364 }
5365
5366
5367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5368   float jresult ;
5369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5370   float result;
5371
5372   arg1 = (Dali::Vector2 *)jarg1;
5373   result = (float) ((arg1)->width);
5374   jresult = result;
5375   return jresult;
5376 }
5377
5378
5379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5381   float arg2 ;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   arg2 = (float)jarg2;
5385   if (arg1) (arg1)->y = arg2;
5386 }
5387
5388
5389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5390   float jresult ;
5391   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5392   float result;
5393
5394   arg1 = (Dali::Vector2 *)jarg1;
5395   result = (float) ((arg1)->y);
5396   jresult = result;
5397   return jresult;
5398 }
5399
5400
5401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5402   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5403   float arg2 ;
5404
5405   arg1 = (Dali::Vector2 *)jarg1;
5406   arg2 = (float)jarg2;
5407   if (arg1) (arg1)->height = arg2;
5408 }
5409
5410
5411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5412   float jresult ;
5413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5414   float result;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   result = (float) ((arg1)->height);
5418   jresult = result;
5419   return jresult;
5420 }
5421
5422
5423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5424   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5425
5426   arg1 = (Dali::Vector2 *)jarg1;
5427   {
5428     try {
5429       delete arg1;
5430     } catch (std::out_of_range& e) {
5431       {
5432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5433       };
5434     } catch (std::exception& e) {
5435       {
5436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (Dali::DaliException e) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5445       };
5446     }
5447   }
5448
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector2 *arg1 = 0 ;
5455   Dali::Vector2 *arg2 = 0 ;
5456   Dali::Vector2 result;
5457
5458   arg1 = (Dali::Vector2 *)jarg1;
5459   if (!arg1) {
5460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5461     return 0;
5462   }
5463   arg2 = (Dali::Vector2 *)jarg2;
5464   if (!arg2) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   {
5469     try {
5470       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5471     } catch (std::out_of_range& e) {
5472       {
5473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (std::exception& e) {
5476       {
5477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (Dali::DaliException e) {
5480       {
5481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5482       };
5483     } catch (...) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5486       };
5487     }
5488   }
5489
5490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5491   return jresult;
5492 }
5493
5494
5495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5496   void * jresult ;
5497   Dali::Vector2 *arg1 = 0 ;
5498   Dali::Vector2 *arg2 = 0 ;
5499   Dali::Vector2 result;
5500
5501   arg1 = (Dali::Vector2 *)jarg1;
5502   if (!arg1) {
5503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5504     return 0;
5505   }
5506   arg2 = (Dali::Vector2 *)jarg2;
5507   if (!arg2) {
5508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5509     return 0;
5510   }
5511   {
5512     try {
5513       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5514     } catch (std::out_of_range& e) {
5515       {
5516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5517       };
5518     } catch (std::exception& e) {
5519       {
5520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (Dali::DaliException e) {
5523       {
5524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5525       };
5526     } catch (...) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5529       };
5530     }
5531   }
5532
5533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5534   return jresult;
5535 }
5536
5537
5538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5539   void * jresult ;
5540   Dali::Vector2 *arg1 = 0 ;
5541   float *arg2 = 0 ;
5542   float *arg3 = 0 ;
5543   float temp2 ;
5544   float temp3 ;
5545   Dali::Vector2 result;
5546
5547   arg1 = (Dali::Vector2 *)jarg1;
5548   if (!arg1) {
5549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5550     return 0;
5551   }
5552   temp2 = (float)jarg2;
5553   arg2 = &temp2;
5554   temp3 = (float)jarg3;
5555   arg3 = &temp3;
5556   {
5557     try {
5558       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5559     } catch (std::out_of_range& e) {
5560       {
5561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5562       };
5563     } catch (std::exception& e) {
5564       {
5565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (Dali::DaliException e) {
5568       {
5569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5570       };
5571     } catch (...) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5574       };
5575     }
5576   }
5577
5578   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5579   return jresult;
5580 }
5581
5582
5583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5584   void * jresult ;
5585   Dali::Vector3 *result = 0 ;
5586
5587   {
5588     try {
5589       result = (Dali::Vector3 *)new Dali::Vector3();
5590     } catch (std::out_of_range& e) {
5591       {
5592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5593       };
5594     } catch (std::exception& e) {
5595       {
5596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (Dali::DaliException e) {
5599       {
5600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5601       };
5602     } catch (...) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5605       };
5606     }
5607   }
5608
5609   jresult = (void *)result;
5610   return jresult;
5611 }
5612
5613
5614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5615   void * jresult ;
5616   float arg1 ;
5617   float arg2 ;
5618   float arg3 ;
5619   Dali::Vector3 *result = 0 ;
5620
5621   arg1 = (float)jarg1;
5622   arg2 = (float)jarg2;
5623   arg3 = (float)jarg3;
5624   {
5625     try {
5626       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5627     } catch (std::out_of_range& e) {
5628       {
5629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5630       };
5631     } catch (std::exception& e) {
5632       {
5633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (Dali::DaliException e) {
5636       {
5637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5638       };
5639     } catch (...) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5642       };
5643     }
5644   }
5645
5646   jresult = (void *)result;
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5652   void * jresult ;
5653   float *arg1 = (float *) 0 ;
5654   Dali::Vector3 *result = 0 ;
5655
5656   arg1 = jarg1;
5657   {
5658     try {
5659       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5660     } catch (std::out_of_range& e) {
5661       {
5662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (std::exception& e) {
5665       {
5666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (Dali::DaliException e) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5671       };
5672     } catch (...) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5675       };
5676     }
5677   }
5678
5679   jresult = (void *)result;
5680
5681
5682   return jresult;
5683 }
5684
5685
5686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5687   void * jresult ;
5688   Dali::Vector2 *arg1 = 0 ;
5689   Dali::Vector3 *result = 0 ;
5690
5691   arg1 = (Dali::Vector2 *)jarg1;
5692   if (!arg1) {
5693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5694     return 0;
5695   }
5696   {
5697     try {
5698       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5699     } catch (std::out_of_range& e) {
5700       {
5701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5702       };
5703     } catch (std::exception& e) {
5704       {
5705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (Dali::DaliException e) {
5708       {
5709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5710       };
5711     } catch (...) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5714       };
5715     }
5716   }
5717
5718   jresult = (void *)result;
5719   return jresult;
5720 }
5721
5722
5723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5724   void * jresult ;
5725   Dali::Vector4 *arg1 = 0 ;
5726   Dali::Vector3 *result = 0 ;
5727
5728   arg1 = (Dali::Vector4 *)jarg1;
5729   if (!arg1) {
5730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5731     return 0;
5732   }
5733   {
5734     try {
5735       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5736     } catch (std::out_of_range& e) {
5737       {
5738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5739       };
5740     } catch (std::exception& e) {
5741       {
5742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (Dali::DaliException e) {
5745       {
5746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5747       };
5748     } catch (...) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5751       };
5752     }
5753   }
5754
5755   jresult = (void *)result;
5756   return jresult;
5757 }
5758
5759
5760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5761   void * jresult ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5765   jresult = (void *)result;
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5771   void * jresult ;
5772   Dali::Vector3 *result = 0 ;
5773
5774   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5775   jresult = (void *)result;
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5781   void * jresult ;
5782   Dali::Vector3 *result = 0 ;
5783
5784   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5785   jresult = (void *)result;
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5791   void * jresult ;
5792   Dali::Vector3 *result = 0 ;
5793
5794   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5795   jresult = (void *)result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5801   void * jresult ;
5802   Dali::Vector3 *result = 0 ;
5803
5804   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5805   jresult = (void *)result;
5806   return jresult;
5807 }
5808
5809
5810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5811   void * jresult ;
5812   Dali::Vector3 *result = 0 ;
5813
5814   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5815   jresult = (void *)result;
5816   return jresult;
5817 }
5818
5819
5820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5821   void * jresult ;
5822   Dali::Vector3 *result = 0 ;
5823
5824   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5825   jresult = (void *)result;
5826   return jresult;
5827 }
5828
5829
5830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5831   void * jresult ;
5832   Dali::Vector3 *result = 0 ;
5833
5834   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5835   jresult = (void *)result;
5836   return jresult;
5837 }
5838
5839
5840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5841   void * jresult ;
5842   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5843   float *arg2 = (float *) 0 ;
5844   Dali::Vector3 *result = 0 ;
5845
5846   arg1 = (Dali::Vector3 *)jarg1;
5847   arg2 = jarg2;
5848   {
5849     try {
5850       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5851     } catch (std::out_of_range& e) {
5852       {
5853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (std::exception& e) {
5856       {
5857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (Dali::DaliException e) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5862       };
5863     } catch (...) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5866       };
5867     }
5868   }
5869
5870   jresult = (void *)result;
5871
5872
5873   return jresult;
5874 }
5875
5876
5877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5878   void * jresult ;
5879   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5880   Dali::Vector2 *arg2 = 0 ;
5881   Dali::Vector3 *result = 0 ;
5882
5883   arg1 = (Dali::Vector3 *)jarg1;
5884   arg2 = (Dali::Vector2 *)jarg2;
5885   if (!arg2) {
5886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5887     return 0;
5888   }
5889   {
5890     try {
5891       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5892     } catch (std::out_of_range& e) {
5893       {
5894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (std::exception& e) {
5897       {
5898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (Dali::DaliException e) {
5901       {
5902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5903       };
5904     } catch (...) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5907       };
5908     }
5909   }
5910
5911   jresult = (void *)result;
5912   return jresult;
5913 }
5914
5915
5916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5917   void * jresult ;
5918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5919   Dali::Vector4 *arg2 = 0 ;
5920   Dali::Vector3 *result = 0 ;
5921
5922   arg1 = (Dali::Vector3 *)jarg1;
5923   arg2 = (Dali::Vector4 *)jarg2;
5924   if (!arg2) {
5925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5926     return 0;
5927   }
5928   {
5929     try {
5930       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5931     } catch (std::out_of_range& e) {
5932       {
5933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5934       };
5935     } catch (std::exception& e) {
5936       {
5937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (Dali::DaliException e) {
5940       {
5941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5942       };
5943     } catch (...) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5946       };
5947     }
5948   }
5949
5950   jresult = (void *)result;
5951   return jresult;
5952 }
5953
5954
5955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5956   void * jresult ;
5957   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5958   Dali::Vector3 *arg2 = 0 ;
5959   Dali::Vector3 result;
5960
5961   arg1 = (Dali::Vector3 *)jarg1;
5962   arg2 = (Dali::Vector3 *)jarg2;
5963   if (!arg2) {
5964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5965     return 0;
5966   }
5967   {
5968     try {
5969       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5970     } catch (std::out_of_range& e) {
5971       {
5972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (std::exception& e) {
5975       {
5976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (Dali::DaliException e) {
5979       {
5980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5981       };
5982     } catch (...) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5985       };
5986     }
5987   }
5988
5989   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5990   return jresult;
5991 }
5992
5993
5994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5995   void * jresult ;
5996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5997   Dali::Vector3 *arg2 = 0 ;
5998   Dali::Vector3 *result = 0 ;
5999
6000   arg1 = (Dali::Vector3 *)jarg1;
6001   arg2 = (Dali::Vector3 *)jarg2;
6002   if (!arg2) {
6003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6004     return 0;
6005   }
6006   {
6007     try {
6008       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6009     } catch (std::out_of_range& e) {
6010       {
6011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6012       };
6013     } catch (std::exception& e) {
6014       {
6015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (Dali::DaliException e) {
6018       {
6019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6020       };
6021     } catch (...) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6024       };
6025     }
6026   }
6027
6028   jresult = (void *)result;
6029   return jresult;
6030 }
6031
6032
6033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6034   void * jresult ;
6035   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6036   Dali::Vector3 *arg2 = 0 ;
6037   Dali::Vector3 result;
6038
6039   arg1 = (Dali::Vector3 *)jarg1;
6040   arg2 = (Dali::Vector3 *)jarg2;
6041   if (!arg2) {
6042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6043     return 0;
6044   }
6045   {
6046     try {
6047       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6048     } catch (std::out_of_range& e) {
6049       {
6050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (std::exception& e) {
6053       {
6054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (Dali::DaliException e) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6059       };
6060     } catch (...) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6063       };
6064     }
6065   }
6066
6067   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6068   return jresult;
6069 }
6070
6071
6072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6073   void * jresult ;
6074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6075   Dali::Vector3 *arg2 = 0 ;
6076   Dali::Vector3 *result = 0 ;
6077
6078   arg1 = (Dali::Vector3 *)jarg1;
6079   arg2 = (Dali::Vector3 *)jarg2;
6080   if (!arg2) {
6081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6082     return 0;
6083   }
6084   {
6085     try {
6086       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6087     } catch (std::out_of_range& e) {
6088       {
6089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6090       };
6091     } catch (std::exception& e) {
6092       {
6093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (Dali::DaliException e) {
6096       {
6097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6098       };
6099     } catch (...) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6102       };
6103     }
6104   }
6105
6106   jresult = (void *)result;
6107   return jresult;
6108 }
6109
6110
6111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6112   void * jresult ;
6113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6114   Dali::Vector3 *arg2 = 0 ;
6115   Dali::Vector3 result;
6116
6117   arg1 = (Dali::Vector3 *)jarg1;
6118   arg2 = (Dali::Vector3 *)jarg2;
6119   if (!arg2) {
6120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6121     return 0;
6122   }
6123   {
6124     try {
6125       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6126     } catch (std::out_of_range& e) {
6127       {
6128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6129       };
6130     } catch (std::exception& e) {
6131       {
6132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (Dali::DaliException e) {
6135       {
6136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6137       };
6138     } catch (...) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6141       };
6142     }
6143   }
6144
6145   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6146   return jresult;
6147 }
6148
6149
6150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6151   void * jresult ;
6152   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6153   float arg2 ;
6154   Dali::Vector3 result;
6155
6156   arg1 = (Dali::Vector3 *)jarg1;
6157   arg2 = (float)jarg2;
6158   {
6159     try {
6160       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6161     } catch (std::out_of_range& e) {
6162       {
6163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6164       };
6165     } catch (std::exception& e) {
6166       {
6167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (Dali::DaliException e) {
6170       {
6171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6172       };
6173     } catch (...) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6176       };
6177     }
6178   }
6179
6180   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6181   return jresult;
6182 }
6183
6184
6185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6186   void * jresult ;
6187   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6188   Dali::Vector3 *arg2 = 0 ;
6189   Dali::Vector3 *result = 0 ;
6190
6191   arg1 = (Dali::Vector3 *)jarg1;
6192   arg2 = (Dali::Vector3 *)jarg2;
6193   if (!arg2) {
6194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6195     return 0;
6196   }
6197   {
6198     try {
6199       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6200     } catch (std::out_of_range& e) {
6201       {
6202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6203       };
6204     } catch (std::exception& e) {
6205       {
6206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (Dali::DaliException e) {
6209       {
6210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6211       };
6212     } catch (...) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6215       };
6216     }
6217   }
6218
6219   jresult = (void *)result;
6220   return jresult;
6221 }
6222
6223
6224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6225   void * jresult ;
6226   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6227   float arg2 ;
6228   Dali::Vector3 *result = 0 ;
6229
6230   arg1 = (Dali::Vector3 *)jarg1;
6231   arg2 = (float)jarg2;
6232   {
6233     try {
6234       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6235     } catch (std::out_of_range& e) {
6236       {
6237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6238       };
6239     } catch (std::exception& e) {
6240       {
6241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (Dali::DaliException e) {
6244       {
6245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6246       };
6247     } catch (...) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6250       };
6251     }
6252   }
6253
6254   jresult = (void *)result;
6255   return jresult;
6256 }
6257
6258
6259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6260   void * jresult ;
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   Dali::Quaternion *arg2 = 0 ;
6263   Dali::Vector3 *result = 0 ;
6264
6265   arg1 = (Dali::Vector3 *)jarg1;
6266   arg2 = (Dali::Quaternion *)jarg2;
6267   if (!arg2) {
6268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6269     return 0;
6270   }
6271   {
6272     try {
6273       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6274     } catch (std::out_of_range& e) {
6275       {
6276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6277       };
6278     } catch (std::exception& e) {
6279       {
6280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (Dali::DaliException e) {
6283       {
6284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6285       };
6286     } catch (...) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6289       };
6290     }
6291   }
6292
6293   jresult = (void *)result;
6294   return jresult;
6295 }
6296
6297
6298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6299   void * jresult ;
6300   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6301   Dali::Vector3 *arg2 = 0 ;
6302   Dali::Vector3 result;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   arg2 = (Dali::Vector3 *)jarg2;
6306   if (!arg2) {
6307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6308     return 0;
6309   }
6310   {
6311     try {
6312       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6313     } catch (std::out_of_range& e) {
6314       {
6315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6316       };
6317     } catch (std::exception& e) {
6318       {
6319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (Dali::DaliException e) {
6322       {
6323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6324       };
6325     } catch (...) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6328       };
6329     }
6330   }
6331
6332   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6333   return jresult;
6334 }
6335
6336
6337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6338   void * jresult ;
6339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6340   float arg2 ;
6341   Dali::Vector3 result;
6342
6343   arg1 = (Dali::Vector3 *)jarg1;
6344   arg2 = (float)jarg2;
6345   {
6346     try {
6347       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6348     } catch (std::out_of_range& e) {
6349       {
6350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6351       };
6352     } catch (std::exception& e) {
6353       {
6354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (Dali::DaliException e) {
6357       {
6358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6359       };
6360     } catch (...) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6363       };
6364     }
6365   }
6366
6367   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6368   return jresult;
6369 }
6370
6371
6372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6373   void * jresult ;
6374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6375   Dali::Vector3 *arg2 = 0 ;
6376   Dali::Vector3 *result = 0 ;
6377
6378   arg1 = (Dali::Vector3 *)jarg1;
6379   arg2 = (Dali::Vector3 *)jarg2;
6380   if (!arg2) {
6381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6382     return 0;
6383   }
6384   {
6385     try {
6386       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6387     } catch (std::out_of_range& e) {
6388       {
6389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6390       };
6391     } catch (std::exception& e) {
6392       {
6393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (Dali::DaliException e) {
6396       {
6397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6398       };
6399     } catch (...) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6402       };
6403     }
6404   }
6405
6406   jresult = (void *)result;
6407   return jresult;
6408 }
6409
6410
6411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6412   void * jresult ;
6413   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6414   float arg2 ;
6415   Dali::Vector3 *result = 0 ;
6416
6417   arg1 = (Dali::Vector3 *)jarg1;
6418   arg2 = (float)jarg2;
6419   {
6420     try {
6421       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6422     } catch (std::out_of_range& e) {
6423       {
6424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6425       };
6426     } catch (std::exception& e) {
6427       {
6428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (Dali::DaliException e) {
6431       {
6432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6433       };
6434     } catch (...) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6437       };
6438     }
6439   }
6440
6441   jresult = (void *)result;
6442   return jresult;
6443 }
6444
6445
6446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6447   void * jresult ;
6448   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6449   Dali::Vector3 result;
6450
6451   arg1 = (Dali::Vector3 *)jarg1;
6452   {
6453     try {
6454       result = ((Dali::Vector3 const *)arg1)->operator -();
6455     } catch (std::out_of_range& e) {
6456       {
6457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6458       };
6459     } catch (std::exception& e) {
6460       {
6461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (Dali::DaliException e) {
6464       {
6465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6466       };
6467     } catch (...) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6470       };
6471     }
6472   }
6473
6474   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6475   return jresult;
6476 }
6477
6478
6479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6480   unsigned int jresult ;
6481   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6482   Dali::Vector3 *arg2 = 0 ;
6483   bool result;
6484
6485   arg1 = (Dali::Vector3 *)jarg1;
6486   arg2 = (Dali::Vector3 *)jarg2;
6487   if (!arg2) {
6488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6489     return 0;
6490   }
6491   {
6492     try {
6493       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6494     } catch (std::out_of_range& e) {
6495       {
6496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (std::exception& e) {
6499       {
6500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (Dali::DaliException e) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6505       };
6506     } catch (...) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6509       };
6510     }
6511   }
6512
6513   jresult = result;
6514   return jresult;
6515 }
6516
6517
6518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6519   unsigned int jresult ;
6520   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6521   Dali::Vector3 *arg2 = 0 ;
6522   bool result;
6523
6524   arg1 = (Dali::Vector3 *)jarg1;
6525   arg2 = (Dali::Vector3 *)jarg2;
6526   if (!arg2) {
6527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6528     return 0;
6529   }
6530   {
6531     try {
6532       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6533     } catch (std::out_of_range& e) {
6534       {
6535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6536       };
6537     } catch (std::exception& e) {
6538       {
6539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (Dali::DaliException e) {
6542       {
6543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6544       };
6545     } catch (...) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6548       };
6549     }
6550   }
6551
6552   jresult = result;
6553   return jresult;
6554 }
6555
6556
6557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6558   float jresult ;
6559   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6560   unsigned int arg2 ;
6561   float *result = 0 ;
6562
6563   arg1 = (Dali::Vector3 *)jarg1;
6564   arg2 = (unsigned int)jarg2;
6565   {
6566     try {
6567       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6568     } catch (std::out_of_range& e) {
6569       {
6570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (std::exception& e) {
6573       {
6574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (Dali::DaliException e) {
6577       {
6578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6579       };
6580     } catch (...) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6583       };
6584     }
6585   }
6586
6587   jresult = *result;
6588   return jresult;
6589 }
6590
6591
6592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6593   float jresult ;
6594   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6595   Dali::Vector3 *arg2 = 0 ;
6596   float result;
6597
6598   arg1 = (Dali::Vector3 *)jarg1;
6599   arg2 = (Dali::Vector3 *)jarg2;
6600   if (!arg2) {
6601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6602     return 0;
6603   }
6604   {
6605     try {
6606       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6607     } catch (std::out_of_range& e) {
6608       {
6609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6610       };
6611     } catch (std::exception& e) {
6612       {
6613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (Dali::DaliException e) {
6616       {
6617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6618       };
6619     } catch (...) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6622       };
6623     }
6624   }
6625
6626   jresult = result;
6627   return jresult;
6628 }
6629
6630
6631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6632   void * jresult ;
6633   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6634   Dali::Vector3 *arg2 = 0 ;
6635   Dali::Vector3 result;
6636
6637   arg1 = (Dali::Vector3 *)jarg1;
6638   arg2 = (Dali::Vector3 *)jarg2;
6639   if (!arg2) {
6640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6641     return 0;
6642   }
6643   {
6644     try {
6645       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (Dali::DaliException e) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6657       };
6658     } catch (...) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6661       };
6662     }
6663   }
6664
6665   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6666   return jresult;
6667 }
6668
6669
6670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6671   float jresult ;
6672   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6673   float result;
6674
6675   arg1 = (Dali::Vector3 *)jarg1;
6676   {
6677     try {
6678       result = (float)((Dali::Vector3 const *)arg1)->Length();
6679     } catch (std::out_of_range& e) {
6680       {
6681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6682       };
6683     } catch (std::exception& e) {
6684       {
6685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (Dali::DaliException e) {
6688       {
6689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6690       };
6691     } catch (...) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6694       };
6695     }
6696   }
6697
6698   jresult = result;
6699   return jresult;
6700 }
6701
6702
6703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6704   float jresult ;
6705   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6706   float result;
6707
6708   arg1 = (Dali::Vector3 *)jarg1;
6709   {
6710     try {
6711       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (Dali::DaliException e) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6723       };
6724     } catch (...) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6727       };
6728     }
6729   }
6730
6731   jresult = result;
6732   return jresult;
6733 }
6734
6735
6736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6737   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6738
6739   arg1 = (Dali::Vector3 *)jarg1;
6740   {
6741     try {
6742       (arg1)->Normalize();
6743     } catch (std::out_of_range& e) {
6744       {
6745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6746       };
6747     } catch (std::exception& e) {
6748       {
6749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (Dali::DaliException e) {
6752       {
6753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6758       };
6759     }
6760   }
6761
6762 }
6763
6764
6765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6766   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6767   Dali::Vector3 *arg2 = 0 ;
6768   Dali::Vector3 *arg3 = 0 ;
6769
6770   arg1 = (Dali::Vector3 *)jarg1;
6771   arg2 = (Dali::Vector3 *)jarg2;
6772   if (!arg2) {
6773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6774     return ;
6775   }
6776   arg3 = (Dali::Vector3 *)jarg3;
6777   if (!arg3) {
6778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6779     return ;
6780   }
6781   {
6782     try {
6783       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6784     } catch (std::out_of_range& e) {
6785       {
6786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6787       };
6788     } catch (std::exception& e) {
6789       {
6790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (Dali::DaliException e) {
6793       {
6794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6795       };
6796     } catch (...) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6799       };
6800     }
6801   }
6802
6803 }
6804
6805
6806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6807   void * jresult ;
6808   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6809   float *result = 0 ;
6810
6811   arg1 = (Dali::Vector3 *)jarg1;
6812   {
6813     try {
6814       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6815     } catch (std::out_of_range& e) {
6816       {
6817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6818       };
6819     } catch (std::exception& e) {
6820       {
6821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (Dali::DaliException e) {
6824       {
6825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6826       };
6827     } catch (...) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6830       };
6831     }
6832   }
6833
6834   jresult = (void *)result;
6835   return jresult;
6836 }
6837
6838
6839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6840   void * jresult ;
6841   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6842   Dali::Vector2 *result = 0 ;
6843
6844   arg1 = (Dali::Vector3 *)jarg1;
6845   {
6846     try {
6847       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6848     } catch (std::out_of_range& e) {
6849       {
6850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6851       };
6852     } catch (std::exception& e) {
6853       {
6854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (Dali::DaliException e) {
6857       {
6858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6859       };
6860     } catch (...) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6863       };
6864     }
6865   }
6866
6867   jresult = (void *)result;
6868   return jresult;
6869 }
6870
6871
6872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6873   void * jresult ;
6874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6875   Dali::Vector2 *result = 0 ;
6876
6877   arg1 = (Dali::Vector3 *)jarg1;
6878   {
6879     try {
6880       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6881     } catch (std::out_of_range& e) {
6882       {
6883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6884       };
6885     } catch (std::exception& e) {
6886       {
6887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (Dali::DaliException e) {
6890       {
6891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6892       };
6893     } catch (...) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6896       };
6897     }
6898   }
6899
6900   jresult = (void *)result;
6901   return jresult;
6902 }
6903
6904
6905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6906   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6907   float arg2 ;
6908
6909   arg1 = (Dali::Vector3 *)jarg1;
6910   arg2 = (float)jarg2;
6911   if (arg1) (arg1)->x = arg2;
6912 }
6913
6914
6915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6916   float jresult ;
6917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6918   float result;
6919
6920   arg1 = (Dali::Vector3 *)jarg1;
6921   result = (float) ((arg1)->x);
6922   jresult = result;
6923   return jresult;
6924 }
6925
6926
6927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6929   float arg2 ;
6930
6931   arg1 = (Dali::Vector3 *)jarg1;
6932   arg2 = (float)jarg2;
6933   if (arg1) (arg1)->width = arg2;
6934 }
6935
6936
6937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6938   float jresult ;
6939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6940   float result;
6941
6942   arg1 = (Dali::Vector3 *)jarg1;
6943   result = (float) ((arg1)->width);
6944   jresult = result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6951   float arg2 ;
6952
6953   arg1 = (Dali::Vector3 *)jarg1;
6954   arg2 = (float)jarg2;
6955   if (arg1) (arg1)->r = arg2;
6956 }
6957
6958
6959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6960   float jresult ;
6961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6962   float result;
6963
6964   arg1 = (Dali::Vector3 *)jarg1;
6965   result = (float) ((arg1)->r);
6966   jresult = result;
6967   return jresult;
6968 }
6969
6970
6971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6973   float arg2 ;
6974
6975   arg1 = (Dali::Vector3 *)jarg1;
6976   arg2 = (float)jarg2;
6977   if (arg1) (arg1)->y = arg2;
6978 }
6979
6980
6981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6982   float jresult ;
6983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6984   float result;
6985
6986   arg1 = (Dali::Vector3 *)jarg1;
6987   result = (float) ((arg1)->y);
6988   jresult = result;
6989   return jresult;
6990 }
6991
6992
6993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6995   float arg2 ;
6996
6997   arg1 = (Dali::Vector3 *)jarg1;
6998   arg2 = (float)jarg2;
6999   if (arg1) (arg1)->height = arg2;
7000 }
7001
7002
7003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7004   float jresult ;
7005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7006   float result;
7007
7008   arg1 = (Dali::Vector3 *)jarg1;
7009   result = (float) ((arg1)->height);
7010   jresult = result;
7011   return jresult;
7012 }
7013
7014
7015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7017   float arg2 ;
7018
7019   arg1 = (Dali::Vector3 *)jarg1;
7020   arg2 = (float)jarg2;
7021   if (arg1) (arg1)->g = arg2;
7022 }
7023
7024
7025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7026   float jresult ;
7027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7028   float result;
7029
7030   arg1 = (Dali::Vector3 *)jarg1;
7031   result = (float) ((arg1)->g);
7032   jresult = result;
7033   return jresult;
7034 }
7035
7036
7037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7039   float arg2 ;
7040
7041   arg1 = (Dali::Vector3 *)jarg1;
7042   arg2 = (float)jarg2;
7043   if (arg1) (arg1)->z = arg2;
7044 }
7045
7046
7047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7048   float jresult ;
7049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7050   float result;
7051
7052   arg1 = (Dali::Vector3 *)jarg1;
7053   result = (float) ((arg1)->z);
7054   jresult = result;
7055   return jresult;
7056 }
7057
7058
7059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7061   float arg2 ;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   arg2 = (float)jarg2;
7065   if (arg1) (arg1)->depth = arg2;
7066 }
7067
7068
7069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7070   float jresult ;
7071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7072   float result;
7073
7074   arg1 = (Dali::Vector3 *)jarg1;
7075   result = (float) ((arg1)->depth);
7076   jresult = result;
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7083   float arg2 ;
7084
7085   arg1 = (Dali::Vector3 *)jarg1;
7086   arg2 = (float)jarg2;
7087   if (arg1) (arg1)->b = arg2;
7088 }
7089
7090
7091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7092   float jresult ;
7093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7094   float result;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   result = (float) ((arg1)->b);
7098   jresult = result;
7099   return jresult;
7100 }
7101
7102
7103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7105
7106   arg1 = (Dali::Vector3 *)jarg1;
7107   {
7108     try {
7109       delete arg1;
7110     } catch (std::out_of_range& e) {
7111       {
7112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7113       };
7114     } catch (std::exception& e) {
7115       {
7116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (Dali::DaliException e) {
7119       {
7120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7121       };
7122     } catch (...) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7125       };
7126     }
7127   }
7128
7129 }
7130
7131
7132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7133   void * jresult ;
7134   Dali::Vector3 *arg1 = 0 ;
7135   Dali::Vector3 *arg2 = 0 ;
7136   Dali::Vector3 result;
7137
7138   arg1 = (Dali::Vector3 *)jarg1;
7139   if (!arg1) {
7140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7141     return 0;
7142   }
7143   arg2 = (Dali::Vector3 *)jarg2;
7144   if (!arg2) {
7145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7146     return 0;
7147   }
7148   {
7149     try {
7150       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7151     } catch (std::out_of_range& e) {
7152       {
7153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7154       };
7155     } catch (std::exception& e) {
7156       {
7157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (Dali::DaliException e) {
7160       {
7161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7162       };
7163     } catch (...) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7166       };
7167     }
7168   }
7169
7170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7171   return jresult;
7172 }
7173
7174
7175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7176   void * jresult ;
7177   Dali::Vector3 *arg1 = 0 ;
7178   Dali::Vector3 *arg2 = 0 ;
7179   Dali::Vector3 result;
7180
7181   arg1 = (Dali::Vector3 *)jarg1;
7182   if (!arg1) {
7183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7184     return 0;
7185   }
7186   arg2 = (Dali::Vector3 *)jarg2;
7187   if (!arg2) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7189     return 0;
7190   }
7191   {
7192     try {
7193       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7194     } catch (std::out_of_range& e) {
7195       {
7196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (std::exception& e) {
7199       {
7200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (Dali::DaliException e) {
7203       {
7204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7205       };
7206     } catch (...) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7209       };
7210     }
7211   }
7212
7213   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7219   void * jresult ;
7220   Dali::Vector3 *arg1 = 0 ;
7221   float *arg2 = 0 ;
7222   float *arg3 = 0 ;
7223   float temp2 ;
7224   float temp3 ;
7225   Dali::Vector3 result;
7226
7227   arg1 = (Dali::Vector3 *)jarg1;
7228   if (!arg1) {
7229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7230     return 0;
7231   }
7232   temp2 = (float)jarg2;
7233   arg2 = &temp2;
7234   temp3 = (float)jarg3;
7235   arg3 = &temp3;
7236   {
7237     try {
7238       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7239     } catch (std::out_of_range& e) {
7240       {
7241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7242       };
7243     } catch (std::exception& e) {
7244       {
7245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (Dali::DaliException e) {
7248       {
7249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7250       };
7251     } catch (...) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7254       };
7255     }
7256   }
7257
7258   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7259   return jresult;
7260 }
7261
7262
7263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7264   void * jresult ;
7265   Dali::Vector4 *result = 0 ;
7266
7267   {
7268     try {
7269       result = (Dali::Vector4 *)new Dali::Vector4();
7270     } catch (std::out_of_range& e) {
7271       {
7272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (std::exception& e) {
7275       {
7276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (Dali::DaliException e) {
7279       {
7280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7281       };
7282     } catch (...) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7285       };
7286     }
7287   }
7288
7289   jresult = (void *)result;
7290   return jresult;
7291 }
7292
7293
7294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7295   void * jresult ;
7296   float arg1 ;
7297   float arg2 ;
7298   float arg3 ;
7299   float arg4 ;
7300   Dali::Vector4 *result = 0 ;
7301
7302   arg1 = (float)jarg1;
7303   arg2 = (float)jarg2;
7304   arg3 = (float)jarg3;
7305   arg4 = (float)jarg4;
7306   {
7307     try {
7308       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7309     } catch (std::out_of_range& e) {
7310       {
7311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7312       };
7313     } catch (std::exception& e) {
7314       {
7315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (Dali::DaliException e) {
7318       {
7319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7320       };
7321     } catch (...) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7324       };
7325     }
7326   }
7327
7328   jresult = (void *)result;
7329   return jresult;
7330 }
7331
7332
7333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7334   void * jresult ;
7335   float *arg1 = (float *) 0 ;
7336   Dali::Vector4 *result = 0 ;
7337
7338   arg1 = jarg1;
7339   {
7340     try {
7341       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7342     } catch (std::out_of_range& e) {
7343       {
7344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7345       };
7346     } catch (std::exception& e) {
7347       {
7348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (Dali::DaliException e) {
7351       {
7352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7353       };
7354     } catch (...) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7357       };
7358     }
7359   }
7360
7361   jresult = (void *)result;
7362
7363
7364   return jresult;
7365 }
7366
7367
7368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7369   void * jresult ;
7370   Dali::Vector2 *arg1 = 0 ;
7371   Dali::Vector4 *result = 0 ;
7372
7373   arg1 = (Dali::Vector2 *)jarg1;
7374   if (!arg1) {
7375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7376     return 0;
7377   }
7378   {
7379     try {
7380       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7381     } catch (std::out_of_range& e) {
7382       {
7383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7384       };
7385     } catch (std::exception& e) {
7386       {
7387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (Dali::DaliException e) {
7390       {
7391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7392       };
7393     } catch (...) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7396       };
7397     }
7398   }
7399
7400   jresult = (void *)result;
7401   return jresult;
7402 }
7403
7404
7405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7406   void * jresult ;
7407   Dali::Vector3 *arg1 = 0 ;
7408   Dali::Vector4 *result = 0 ;
7409
7410   arg1 = (Dali::Vector3 *)jarg1;
7411   if (!arg1) {
7412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7413     return 0;
7414   }
7415   {
7416     try {
7417       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7418     } catch (std::out_of_range& e) {
7419       {
7420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (std::exception& e) {
7423       {
7424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (Dali::DaliException e) {
7427       {
7428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7429       };
7430     } catch (...) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7433       };
7434     }
7435   }
7436
7437   jresult = (void *)result;
7438   return jresult;
7439 }
7440
7441
7442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7443   void * jresult ;
7444   Dali::Vector4 *result = 0 ;
7445
7446   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7447   jresult = (void *)result;
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7453   void * jresult ;
7454   Dali::Vector4 *result = 0 ;
7455
7456   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7457   jresult = (void *)result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7463   void * jresult ;
7464   Dali::Vector4 *result = 0 ;
7465
7466   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7473   void * jresult ;
7474   Dali::Vector4 *result = 0 ;
7475
7476   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7477   jresult = (void *)result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7483   void * jresult ;
7484   Dali::Vector4 *result = 0 ;
7485
7486   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7487   jresult = (void *)result;
7488   return jresult;
7489 }
7490
7491
7492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7493   void * jresult ;
7494   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7495   float *arg2 = (float *) 0 ;
7496   Dali::Vector4 *result = 0 ;
7497
7498   arg1 = (Dali::Vector4 *)jarg1;
7499   arg2 = jarg2;
7500   {
7501     try {
7502       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7503     } catch (std::out_of_range& e) {
7504       {
7505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7506       };
7507     } catch (std::exception& e) {
7508       {
7509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (Dali::DaliException e) {
7512       {
7513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7514       };
7515     } catch (...) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7518       };
7519     }
7520   }
7521
7522   jresult = (void *)result;
7523
7524
7525   return jresult;
7526 }
7527
7528
7529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7530   void * jresult ;
7531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7532   Dali::Vector2 *arg2 = 0 ;
7533   Dali::Vector4 *result = 0 ;
7534
7535   arg1 = (Dali::Vector4 *)jarg1;
7536   arg2 = (Dali::Vector2 *)jarg2;
7537   if (!arg2) {
7538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7539     return 0;
7540   }
7541   {
7542     try {
7543       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7544     } catch (std::out_of_range& e) {
7545       {
7546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (std::exception& e) {
7549       {
7550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (Dali::DaliException e) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7555       };
7556     } catch (...) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7559       };
7560     }
7561   }
7562
7563   jresult = (void *)result;
7564   return jresult;
7565 }
7566
7567
7568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7569   void * jresult ;
7570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7571   Dali::Vector3 *arg2 = 0 ;
7572   Dali::Vector4 *result = 0 ;
7573
7574   arg1 = (Dali::Vector4 *)jarg1;
7575   arg2 = (Dali::Vector3 *)jarg2;
7576   if (!arg2) {
7577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7578     return 0;
7579   }
7580   {
7581     try {
7582       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7583     } catch (std::out_of_range& e) {
7584       {
7585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7586       };
7587     } catch (std::exception& e) {
7588       {
7589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (Dali::DaliException e) {
7592       {
7593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7594       };
7595     } catch (...) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7598       };
7599     }
7600   }
7601
7602   jresult = (void *)result;
7603   return jresult;
7604 }
7605
7606
7607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7608   void * jresult ;
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   Dali::Vector4 *arg2 = 0 ;
7611   Dali::Vector4 result;
7612
7613   arg1 = (Dali::Vector4 *)jarg1;
7614   arg2 = (Dali::Vector4 *)jarg2;
7615   if (!arg2) {
7616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7617     return 0;
7618   }
7619   {
7620     try {
7621       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7622     } catch (std::out_of_range& e) {
7623       {
7624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7625       };
7626     } catch (std::exception& e) {
7627       {
7628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (Dali::DaliException e) {
7631       {
7632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7633       };
7634     } catch (...) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7637       };
7638     }
7639   }
7640
7641   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7642   return jresult;
7643 }
7644
7645
7646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7647   void * jresult ;
7648   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7649   Dali::Vector4 *arg2 = 0 ;
7650   Dali::Vector4 *result = 0 ;
7651
7652   arg1 = (Dali::Vector4 *)jarg1;
7653   arg2 = (Dali::Vector4 *)jarg2;
7654   if (!arg2) {
7655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7656     return 0;
7657   }
7658   {
7659     try {
7660       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7661     } catch (std::out_of_range& e) {
7662       {
7663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7664       };
7665     } catch (std::exception& e) {
7666       {
7667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (Dali::DaliException e) {
7670       {
7671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7672       };
7673     } catch (...) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7676       };
7677     }
7678   }
7679
7680   jresult = (void *)result;
7681   return jresult;
7682 }
7683
7684
7685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7686   void * jresult ;
7687   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7688   Dali::Vector4 *arg2 = 0 ;
7689   Dali::Vector4 result;
7690
7691   arg1 = (Dali::Vector4 *)jarg1;
7692   arg2 = (Dali::Vector4 *)jarg2;
7693   if (!arg2) {
7694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7695     return 0;
7696   }
7697   {
7698     try {
7699       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7700     } catch (std::out_of_range& e) {
7701       {
7702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7703       };
7704     } catch (std::exception& e) {
7705       {
7706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (Dali::DaliException e) {
7709       {
7710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7711       };
7712     } catch (...) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7715       };
7716     }
7717   }
7718
7719   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7720   return jresult;
7721 }
7722
7723
7724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7725   void * jresult ;
7726   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7727   Dali::Vector4 *arg2 = 0 ;
7728   Dali::Vector4 *result = 0 ;
7729
7730   arg1 = (Dali::Vector4 *)jarg1;
7731   arg2 = (Dali::Vector4 *)jarg2;
7732   if (!arg2) {
7733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7734     return 0;
7735   }
7736   {
7737     try {
7738       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7739     } catch (std::out_of_range& e) {
7740       {
7741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7742       };
7743     } catch (std::exception& e) {
7744       {
7745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (Dali::DaliException e) {
7748       {
7749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7750       };
7751     } catch (...) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7754       };
7755     }
7756   }
7757
7758   jresult = (void *)result;
7759   return jresult;
7760 }
7761
7762
7763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7764   void * jresult ;
7765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7766   Dali::Vector4 *arg2 = 0 ;
7767   Dali::Vector4 result;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   arg2 = (Dali::Vector4 *)jarg2;
7771   if (!arg2) {
7772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7773     return 0;
7774   }
7775   {
7776     try {
7777       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7778     } catch (std::out_of_range& e) {
7779       {
7780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7781       };
7782     } catch (std::exception& e) {
7783       {
7784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (Dali::DaliException e) {
7787       {
7788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7789       };
7790     } catch (...) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7793       };
7794     }
7795   }
7796
7797   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7798   return jresult;
7799 }
7800
7801
7802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7803   void * jresult ;
7804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7805   float arg2 ;
7806   Dali::Vector4 result;
7807
7808   arg1 = (Dali::Vector4 *)jarg1;
7809   arg2 = (float)jarg2;
7810   {
7811     try {
7812       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7813     } catch (std::out_of_range& e) {
7814       {
7815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7816       };
7817     } catch (std::exception& e) {
7818       {
7819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (Dali::DaliException e) {
7822       {
7823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7824       };
7825     } catch (...) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7828       };
7829     }
7830   }
7831
7832   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7833   return jresult;
7834 }
7835
7836
7837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7838   void * jresult ;
7839   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7840   Dali::Vector4 *arg2 = 0 ;
7841   Dali::Vector4 *result = 0 ;
7842
7843   arg1 = (Dali::Vector4 *)jarg1;
7844   arg2 = (Dali::Vector4 *)jarg2;
7845   if (!arg2) {
7846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7847     return 0;
7848   }
7849   {
7850     try {
7851       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7852     } catch (std::out_of_range& e) {
7853       {
7854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7855       };
7856     } catch (std::exception& e) {
7857       {
7858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (Dali::DaliException e) {
7861       {
7862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7863       };
7864     } catch (...) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7867       };
7868     }
7869   }
7870
7871   jresult = (void *)result;
7872   return jresult;
7873 }
7874
7875
7876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7877   void * jresult ;
7878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7879   float arg2 ;
7880   Dali::Vector4 *result = 0 ;
7881
7882   arg1 = (Dali::Vector4 *)jarg1;
7883   arg2 = (float)jarg2;
7884   {
7885     try {
7886       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7887     } catch (std::out_of_range& e) {
7888       {
7889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (std::exception& e) {
7892       {
7893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (Dali::DaliException e) {
7896       {
7897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7898       };
7899     } catch (...) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7902       };
7903     }
7904   }
7905
7906   jresult = (void *)result;
7907   return jresult;
7908 }
7909
7910
7911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7912   void * jresult ;
7913   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7914   Dali::Vector4 *arg2 = 0 ;
7915   Dali::Vector4 result;
7916
7917   arg1 = (Dali::Vector4 *)jarg1;
7918   arg2 = (Dali::Vector4 *)jarg2;
7919   if (!arg2) {
7920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7921     return 0;
7922   }
7923   {
7924     try {
7925       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7926     } catch (std::out_of_range& e) {
7927       {
7928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7929       };
7930     } catch (std::exception& e) {
7931       {
7932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (Dali::DaliException e) {
7935       {
7936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7937       };
7938     } catch (...) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7941       };
7942     }
7943   }
7944
7945   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7946   return jresult;
7947 }
7948
7949
7950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7951   void * jresult ;
7952   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7953   float arg2 ;
7954   Dali::Vector4 result;
7955
7956   arg1 = (Dali::Vector4 *)jarg1;
7957   arg2 = (float)jarg2;
7958   {
7959     try {
7960       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7961     } catch (std::out_of_range& e) {
7962       {
7963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7964       };
7965     } catch (std::exception& e) {
7966       {
7967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (Dali::DaliException e) {
7970       {
7971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7972       };
7973     } catch (...) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7976       };
7977     }
7978   }
7979
7980   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7981   return jresult;
7982 }
7983
7984
7985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7986   void * jresult ;
7987   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7988   Dali::Vector4 *arg2 = 0 ;
7989   Dali::Vector4 *result = 0 ;
7990
7991   arg1 = (Dali::Vector4 *)jarg1;
7992   arg2 = (Dali::Vector4 *)jarg2;
7993   if (!arg2) {
7994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7995     return 0;
7996   }
7997   {
7998     try {
7999       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8000     } catch (std::out_of_range& e) {
8001       {
8002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8003       };
8004     } catch (std::exception& e) {
8005       {
8006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (Dali::DaliException e) {
8009       {
8010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8011       };
8012     } catch (...) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8015       };
8016     }
8017   }
8018
8019   jresult = (void *)result;
8020   return jresult;
8021 }
8022
8023
8024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8025   void * jresult ;
8026   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8027   float arg2 ;
8028   Dali::Vector4 *result = 0 ;
8029
8030   arg1 = (Dali::Vector4 *)jarg1;
8031   arg2 = (float)jarg2;
8032   {
8033     try {
8034       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8035     } catch (std::out_of_range& e) {
8036       {
8037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8038       };
8039     } catch (std::exception& e) {
8040       {
8041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (Dali::DaliException e) {
8044       {
8045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8046       };
8047     } catch (...) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8050       };
8051     }
8052   }
8053
8054   jresult = (void *)result;
8055   return jresult;
8056 }
8057
8058
8059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8060   void * jresult ;
8061   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8062   Dali::Vector4 result;
8063
8064   arg1 = (Dali::Vector4 *)jarg1;
8065   {
8066     try {
8067       result = ((Dali::Vector4 const *)arg1)->operator -();
8068     } catch (std::out_of_range& e) {
8069       {
8070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (std::exception& e) {
8073       {
8074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (Dali::DaliException e) {
8077       {
8078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8079       };
8080     } catch (...) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8083       };
8084     }
8085   }
8086
8087   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8088   return jresult;
8089 }
8090
8091
8092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8093   unsigned int jresult ;
8094   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8095   Dali::Vector4 *arg2 = 0 ;
8096   bool result;
8097
8098   arg1 = (Dali::Vector4 *)jarg1;
8099   arg2 = (Dali::Vector4 *)jarg2;
8100   if (!arg2) {
8101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8102     return 0;
8103   }
8104   {
8105     try {
8106       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8107     } catch (std::out_of_range& e) {
8108       {
8109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8110       };
8111     } catch (std::exception& e) {
8112       {
8113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (Dali::DaliException e) {
8116       {
8117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8118       };
8119     } catch (...) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8122       };
8123     }
8124   }
8125
8126   jresult = result;
8127   return jresult;
8128 }
8129
8130
8131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8132   unsigned int jresult ;
8133   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8134   Dali::Vector4 *arg2 = 0 ;
8135   bool result;
8136
8137   arg1 = (Dali::Vector4 *)jarg1;
8138   arg2 = (Dali::Vector4 *)jarg2;
8139   if (!arg2) {
8140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8141     return 0;
8142   }
8143   {
8144     try {
8145       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8146     } catch (std::out_of_range& e) {
8147       {
8148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8149       };
8150     } catch (std::exception& e) {
8151       {
8152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (Dali::DaliException e) {
8155       {
8156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8157       };
8158     } catch (...) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8161       };
8162     }
8163   }
8164
8165   jresult = result;
8166   return jresult;
8167 }
8168
8169
8170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8171   float jresult ;
8172   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8173   unsigned int arg2 ;
8174   float *result = 0 ;
8175
8176   arg1 = (Dali::Vector4 *)jarg1;
8177   arg2 = (unsigned int)jarg2;
8178   {
8179     try {
8180       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8181     } catch (std::out_of_range& e) {
8182       {
8183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (std::exception& e) {
8186       {
8187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (Dali::DaliException e) {
8190       {
8191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8192       };
8193     } catch (...) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8196       };
8197     }
8198   }
8199
8200   jresult = *result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8206   float jresult ;
8207   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8208   Dali::Vector3 *arg2 = 0 ;
8209   float result;
8210
8211   arg1 = (Dali::Vector4 *)jarg1;
8212   arg2 = (Dali::Vector3 *)jarg2;
8213   if (!arg2) {
8214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8215     return 0;
8216   }
8217   {
8218     try {
8219       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8220     } catch (std::out_of_range& e) {
8221       {
8222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8223       };
8224     } catch (std::exception& e) {
8225       {
8226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (Dali::DaliException e) {
8229       {
8230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8231       };
8232     } catch (...) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8235       };
8236     }
8237   }
8238
8239   jresult = result;
8240   return jresult;
8241 }
8242
8243
8244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8245   float jresult ;
8246   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8247   Dali::Vector4 *arg2 = 0 ;
8248   float result;
8249
8250   arg1 = (Dali::Vector4 *)jarg1;
8251   arg2 = (Dali::Vector4 *)jarg2;
8252   if (!arg2) {
8253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8254     return 0;
8255   }
8256   {
8257     try {
8258       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8259     } catch (std::out_of_range& e) {
8260       {
8261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (std::exception& e) {
8264       {
8265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (Dali::DaliException e) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8270       };
8271     } catch (...) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8274       };
8275     }
8276   }
8277
8278   jresult = result;
8279   return jresult;
8280 }
8281
8282
8283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8284   float jresult ;
8285   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8286   Dali::Vector4 *arg2 = 0 ;
8287   float result;
8288
8289   arg1 = (Dali::Vector4 *)jarg1;
8290   arg2 = (Dali::Vector4 *)jarg2;
8291   if (!arg2) {
8292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8293     return 0;
8294   }
8295   {
8296     try {
8297       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8298     } catch (std::out_of_range& e) {
8299       {
8300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (std::exception& e) {
8303       {
8304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (Dali::DaliException e) {
8307       {
8308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8309       };
8310     } catch (...) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8313       };
8314     }
8315   }
8316
8317   jresult = result;
8318   return jresult;
8319 }
8320
8321
8322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8323   void * jresult ;
8324   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8325   Dali::Vector4 *arg2 = 0 ;
8326   Dali::Vector4 result;
8327
8328   arg1 = (Dali::Vector4 *)jarg1;
8329   arg2 = (Dali::Vector4 *)jarg2;
8330   if (!arg2) {
8331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8332     return 0;
8333   }
8334   {
8335     try {
8336       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8337     } catch (std::out_of_range& e) {
8338       {
8339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8340       };
8341     } catch (std::exception& e) {
8342       {
8343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (Dali::DaliException e) {
8346       {
8347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8348       };
8349     } catch (...) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8352       };
8353     }
8354   }
8355
8356   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8362   float jresult ;
8363   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8364   float result;
8365
8366   arg1 = (Dali::Vector4 *)jarg1;
8367   {
8368     try {
8369       result = (float)((Dali::Vector4 const *)arg1)->Length();
8370     } catch (std::out_of_range& e) {
8371       {
8372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8373       };
8374     } catch (std::exception& e) {
8375       {
8376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (Dali::DaliException e) {
8379       {
8380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8381       };
8382     } catch (...) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8385       };
8386     }
8387   }
8388
8389   jresult = result;
8390   return jresult;
8391 }
8392
8393
8394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8395   float jresult ;
8396   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8397   float result;
8398
8399   arg1 = (Dali::Vector4 *)jarg1;
8400   {
8401     try {
8402       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8403     } catch (std::out_of_range& e) {
8404       {
8405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8406       };
8407     } catch (std::exception& e) {
8408       {
8409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (Dali::DaliException e) {
8412       {
8413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8414       };
8415     } catch (...) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8418       };
8419     }
8420   }
8421
8422   jresult = result;
8423   return jresult;
8424 }
8425
8426
8427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8428   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8429
8430   arg1 = (Dali::Vector4 *)jarg1;
8431   {
8432     try {
8433       (arg1)->Normalize();
8434     } catch (std::out_of_range& e) {
8435       {
8436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8437       };
8438     } catch (std::exception& e) {
8439       {
8440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (Dali::DaliException e) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8445       };
8446     } catch (...) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8449       };
8450     }
8451   }
8452
8453 }
8454
8455
8456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8457   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8458   Dali::Vector4 *arg2 = 0 ;
8459   Dali::Vector4 *arg3 = 0 ;
8460
8461   arg1 = (Dali::Vector4 *)jarg1;
8462   arg2 = (Dali::Vector4 *)jarg2;
8463   if (!arg2) {
8464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8465     return ;
8466   }
8467   arg3 = (Dali::Vector4 *)jarg3;
8468   if (!arg3) {
8469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8470     return ;
8471   }
8472   {
8473     try {
8474       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8475     } catch (std::out_of_range& e) {
8476       {
8477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8478       };
8479     } catch (std::exception& e) {
8480       {
8481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (Dali::DaliException e) {
8484       {
8485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8486       };
8487     } catch (...) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8490       };
8491     }
8492   }
8493
8494 }
8495
8496
8497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8498   void * jresult ;
8499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8500   float *result = 0 ;
8501
8502   arg1 = (Dali::Vector4 *)jarg1;
8503   {
8504     try {
8505       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8506     } catch (std::out_of_range& e) {
8507       {
8508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8509       };
8510     } catch (std::exception& e) {
8511       {
8512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (Dali::DaliException e) {
8515       {
8516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8517       };
8518     } catch (...) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8521       };
8522     }
8523   }
8524
8525   jresult = (void *)result;
8526   return jresult;
8527 }
8528
8529
8530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8531   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8532   float arg2 ;
8533
8534   arg1 = (Dali::Vector4 *)jarg1;
8535   arg2 = (float)jarg2;
8536   if (arg1) (arg1)->x = arg2;
8537 }
8538
8539
8540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8541   float jresult ;
8542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8543   float result;
8544
8545   arg1 = (Dali::Vector4 *)jarg1;
8546   result = (float) ((arg1)->x);
8547   jresult = result;
8548   return jresult;
8549 }
8550
8551
8552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8554   float arg2 ;
8555
8556   arg1 = (Dali::Vector4 *)jarg1;
8557   arg2 = (float)jarg2;
8558   if (arg1) (arg1)->r = arg2;
8559 }
8560
8561
8562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8563   float jresult ;
8564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8565   float result;
8566
8567   arg1 = (Dali::Vector4 *)jarg1;
8568   result = (float) ((arg1)->r);
8569   jresult = result;
8570   return jresult;
8571 }
8572
8573
8574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8576   float arg2 ;
8577
8578   arg1 = (Dali::Vector4 *)jarg1;
8579   arg2 = (float)jarg2;
8580   if (arg1) (arg1)->s = arg2;
8581 }
8582
8583
8584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8585   float jresult ;
8586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8587   float result;
8588
8589   arg1 = (Dali::Vector4 *)jarg1;
8590   result = (float) ((arg1)->s);
8591   jresult = result;
8592   return jresult;
8593 }
8594
8595
8596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8598   float arg2 ;
8599
8600   arg1 = (Dali::Vector4 *)jarg1;
8601   arg2 = (float)jarg2;
8602   if (arg1) (arg1)->y = arg2;
8603 }
8604
8605
8606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8607   float jresult ;
8608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8609   float result;
8610
8611   arg1 = (Dali::Vector4 *)jarg1;
8612   result = (float) ((arg1)->y);
8613   jresult = result;
8614   return jresult;
8615 }
8616
8617
8618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8620   float arg2 ;
8621
8622   arg1 = (Dali::Vector4 *)jarg1;
8623   arg2 = (float)jarg2;
8624   if (arg1) (arg1)->g = arg2;
8625 }
8626
8627
8628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8629   float jresult ;
8630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8631   float result;
8632
8633   arg1 = (Dali::Vector4 *)jarg1;
8634   result = (float) ((arg1)->g);
8635   jresult = result;
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8642   float arg2 ;
8643
8644   arg1 = (Dali::Vector4 *)jarg1;
8645   arg2 = (float)jarg2;
8646   if (arg1) (arg1)->t = arg2;
8647 }
8648
8649
8650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8651   float jresult ;
8652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8653   float result;
8654
8655   arg1 = (Dali::Vector4 *)jarg1;
8656   result = (float) ((arg1)->t);
8657   jresult = result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8664   float arg2 ;
8665
8666   arg1 = (Dali::Vector4 *)jarg1;
8667   arg2 = (float)jarg2;
8668   if (arg1) (arg1)->z = arg2;
8669 }
8670
8671
8672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8673   float jresult ;
8674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8675   float result;
8676
8677   arg1 = (Dali::Vector4 *)jarg1;
8678   result = (float) ((arg1)->z);
8679   jresult = result;
8680   return jresult;
8681 }
8682
8683
8684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8686   float arg2 ;
8687
8688   arg1 = (Dali::Vector4 *)jarg1;
8689   arg2 = (float)jarg2;
8690   if (arg1) (arg1)->b = arg2;
8691 }
8692
8693
8694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8695   float jresult ;
8696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8697   float result;
8698
8699   arg1 = (Dali::Vector4 *)jarg1;
8700   result = (float) ((arg1)->b);
8701   jresult = result;
8702   return jresult;
8703 }
8704
8705
8706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8708   float arg2 ;
8709
8710   arg1 = (Dali::Vector4 *)jarg1;
8711   arg2 = (float)jarg2;
8712   if (arg1) (arg1)->p = arg2;
8713 }
8714
8715
8716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8717   float jresult ;
8718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8719   float result;
8720
8721   arg1 = (Dali::Vector4 *)jarg1;
8722   result = (float) ((arg1)->p);
8723   jresult = result;
8724   return jresult;
8725 }
8726
8727
8728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8730   float arg2 ;
8731
8732   arg1 = (Dali::Vector4 *)jarg1;
8733   arg2 = (float)jarg2;
8734   if (arg1) (arg1)->w = arg2;
8735 }
8736
8737
8738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8739   float jresult ;
8740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8741   float result;
8742
8743   arg1 = (Dali::Vector4 *)jarg1;
8744   result = (float) ((arg1)->w);
8745   jresult = result;
8746   return jresult;
8747 }
8748
8749
8750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8752   float arg2 ;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   arg2 = (float)jarg2;
8756   if (arg1) (arg1)->a = arg2;
8757 }
8758
8759
8760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8761   float jresult ;
8762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8763   float result;
8764
8765   arg1 = (Dali::Vector4 *)jarg1;
8766   result = (float) ((arg1)->a);
8767   jresult = result;
8768   return jresult;
8769 }
8770
8771
8772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8774   float arg2 ;
8775
8776   arg1 = (Dali::Vector4 *)jarg1;
8777   arg2 = (float)jarg2;
8778   if (arg1) (arg1)->q = arg2;
8779 }
8780
8781
8782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8783   float jresult ;
8784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8785   float result;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   result = (float) ((arg1)->q);
8789   jresult = result;
8790   return jresult;
8791 }
8792
8793
8794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8796
8797   arg1 = (Dali::Vector4 *)jarg1;
8798   {
8799     try {
8800       delete arg1;
8801     } catch (std::out_of_range& e) {
8802       {
8803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8804       };
8805     } catch (std::exception& e) {
8806       {
8807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (Dali::DaliException e) {
8810       {
8811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8812       };
8813     } catch (...) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8816       };
8817     }
8818   }
8819
8820 }
8821
8822
8823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8824   void * jresult ;
8825   Dali::Vector4 *arg1 = 0 ;
8826   Dali::Vector4 *arg2 = 0 ;
8827   Dali::Vector4 result;
8828
8829   arg1 = (Dali::Vector4 *)jarg1;
8830   if (!arg1) {
8831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8832     return 0;
8833   }
8834   arg2 = (Dali::Vector4 *)jarg2;
8835   if (!arg2) {
8836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8837     return 0;
8838   }
8839   {
8840     try {
8841       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8842     } catch (std::out_of_range& e) {
8843       {
8844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8845       };
8846     } catch (std::exception& e) {
8847       {
8848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (Dali::DaliException e) {
8851       {
8852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8853       };
8854     } catch (...) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8857       };
8858     }
8859   }
8860
8861   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8867   void * jresult ;
8868   Dali::Vector4 *arg1 = 0 ;
8869   Dali::Vector4 *arg2 = 0 ;
8870   Dali::Vector4 result;
8871
8872   arg1 = (Dali::Vector4 *)jarg1;
8873   if (!arg1) {
8874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8875     return 0;
8876   }
8877   arg2 = (Dali::Vector4 *)jarg2;
8878   if (!arg2) {
8879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8880     return 0;
8881   }
8882   {
8883     try {
8884       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8885     } catch (std::out_of_range& e) {
8886       {
8887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8888       };
8889     } catch (std::exception& e) {
8890       {
8891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (Dali::DaliException e) {
8894       {
8895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8896       };
8897     } catch (...) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8900       };
8901     }
8902   }
8903
8904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8905   return jresult;
8906 }
8907
8908
8909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8910   void * jresult ;
8911   Dali::Vector4 *arg1 = 0 ;
8912   float *arg2 = 0 ;
8913   float *arg3 = 0 ;
8914   float temp2 ;
8915   float temp3 ;
8916   Dali::Vector4 result;
8917
8918   arg1 = (Dali::Vector4 *)jarg1;
8919   if (!arg1) {
8920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8921     return 0;
8922   }
8923   temp2 = (float)jarg2;
8924   arg2 = &temp2;
8925   temp3 = (float)jarg3;
8926   arg3 = &temp3;
8927   {
8928     try {
8929       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (Dali::DaliException e) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8941       };
8942     } catch (...) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8945       };
8946     }
8947   }
8948
8949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8950   return jresult;
8951 }
8952
8953
8954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8955   void * jresult ;
8956   Dali::Uint16Pair *result = 0 ;
8957
8958   {
8959     try {
8960       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8961     } catch (std::out_of_range& e) {
8962       {
8963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8964       };
8965     } catch (std::exception& e) {
8966       {
8967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (Dali::DaliException e) {
8970       {
8971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8972       };
8973     } catch (...) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8976       };
8977     }
8978   }
8979
8980   jresult = (void *)result;
8981   return jresult;
8982 }
8983
8984
8985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8986   void * jresult ;
8987   uint32_t arg1 ;
8988   uint32_t arg2 ;
8989   Dali::Uint16Pair *result = 0 ;
8990
8991   arg1 = (uint32_t)jarg1;
8992   arg2 = (uint32_t)jarg2;
8993   {
8994     try {
8995       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8996     } catch (std::out_of_range& e) {
8997       {
8998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8999       };
9000     } catch (std::exception& e) {
9001       {
9002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (Dali::DaliException e) {
9005       {
9006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9007       };
9008     } catch (...) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9011       };
9012     }
9013   }
9014
9015   jresult = (void *)result;
9016   return jresult;
9017 }
9018
9019
9020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9021   void * jresult ;
9022   Dali::Uint16Pair *arg1 = 0 ;
9023   Dali::Uint16Pair *result = 0 ;
9024
9025   arg1 = (Dali::Uint16Pair *)jarg1;
9026   if (!arg1) {
9027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9028     return 0;
9029   }
9030   {
9031     try {
9032       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9033     } catch (std::out_of_range& e) {
9034       {
9035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9036       };
9037     } catch (std::exception& e) {
9038       {
9039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (Dali::DaliException e) {
9042       {
9043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9044       };
9045     } catch (...) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9048       };
9049     }
9050   }
9051
9052   jresult = (void *)result;
9053   return jresult;
9054 }
9055
9056
9057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9058   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9059   uint16_t arg2 ;
9060
9061   arg1 = (Dali::Uint16Pair *)jarg1;
9062   arg2 = (uint16_t)jarg2;
9063   {
9064     try {
9065       (arg1)->SetWidth(arg2);
9066     } catch (std::out_of_range& e) {
9067       {
9068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9069       };
9070     } catch (std::exception& e) {
9071       {
9072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (Dali::DaliException e) {
9075       {
9076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9077       };
9078     } catch (...) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9081       };
9082     }
9083   }
9084
9085 }
9086
9087
9088 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9089   unsigned short jresult ;
9090   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9091   uint16_t result;
9092
9093   arg1 = (Dali::Uint16Pair *)jarg1;
9094   {
9095     try {
9096       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9097     } catch (std::out_of_range& e) {
9098       {
9099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9100       };
9101     } catch (std::exception& e) {
9102       {
9103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (Dali::DaliException e) {
9106       {
9107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9108       };
9109     } catch (...) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9112       };
9113     }
9114   }
9115
9116   jresult = result;
9117   return jresult;
9118 }
9119
9120
9121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9122   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9123   uint16_t arg2 ;
9124
9125   arg1 = (Dali::Uint16Pair *)jarg1;
9126   arg2 = (uint16_t)jarg2;
9127   {
9128     try {
9129       (arg1)->SetHeight(arg2);
9130     } catch (std::out_of_range& e) {
9131       {
9132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9133       };
9134     } catch (std::exception& e) {
9135       {
9136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (Dali::DaliException e) {
9139       {
9140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9141       };
9142     } catch (...) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9145       };
9146     }
9147   }
9148
9149 }
9150
9151
9152 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9153   unsigned short jresult ;
9154   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9155   uint16_t result;
9156
9157   arg1 = (Dali::Uint16Pair *)jarg1;
9158   {
9159     try {
9160       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9161     } catch (std::out_of_range& e) {
9162       {
9163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9164       };
9165     } catch (std::exception& e) {
9166       {
9167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (Dali::DaliException e) {
9170       {
9171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9172       };
9173     } catch (...) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9176       };
9177     }
9178   }
9179
9180   jresult = result;
9181   return jresult;
9182 }
9183
9184
9185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9186   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9187   uint16_t arg2 ;
9188
9189   arg1 = (Dali::Uint16Pair *)jarg1;
9190   arg2 = (uint16_t)jarg2;
9191   {
9192     try {
9193       (arg1)->SetX(arg2);
9194     } catch (std::out_of_range& e) {
9195       {
9196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9197       };
9198     } catch (std::exception& e) {
9199       {
9200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (Dali::DaliException e) {
9203       {
9204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9205       };
9206     } catch (...) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9209       };
9210     }
9211   }
9212
9213 }
9214
9215
9216 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9217   unsigned short jresult ;
9218   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9219   uint16_t result;
9220
9221   arg1 = (Dali::Uint16Pair *)jarg1;
9222   {
9223     try {
9224       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9225     } catch (std::out_of_range& e) {
9226       {
9227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9228       };
9229     } catch (std::exception& e) {
9230       {
9231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (Dali::DaliException e) {
9234       {
9235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9236       };
9237     } catch (...) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9240       };
9241     }
9242   }
9243
9244   jresult = result;
9245   return jresult;
9246 }
9247
9248
9249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9250   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9251   uint16_t arg2 ;
9252
9253   arg1 = (Dali::Uint16Pair *)jarg1;
9254   arg2 = (uint16_t)jarg2;
9255   {
9256     try {
9257       (arg1)->SetY(arg2);
9258     } catch (std::out_of_range& e) {
9259       {
9260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9261       };
9262     } catch (std::exception& e) {
9263       {
9264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (Dali::DaliException e) {
9267       {
9268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9269       };
9270     } catch (...) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9273       };
9274     }
9275   }
9276
9277 }
9278
9279
9280 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9281   unsigned short jresult ;
9282   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9283   uint16_t result;
9284
9285   arg1 = (Dali::Uint16Pair *)jarg1;
9286   {
9287     try {
9288       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9289     } catch (std::out_of_range& e) {
9290       {
9291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (std::exception& e) {
9294       {
9295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (Dali::DaliException e) {
9298       {
9299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9300       };
9301     } catch (...) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9304       };
9305     }
9306   }
9307
9308   jresult = result;
9309   return jresult;
9310 }
9311
9312
9313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9314   void * jresult ;
9315   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9316   Dali::Uint16Pair *arg2 = 0 ;
9317   Dali::Uint16Pair *result = 0 ;
9318
9319   arg1 = (Dali::Uint16Pair *)jarg1;
9320   arg2 = (Dali::Uint16Pair *)jarg2;
9321   if (!arg2) {
9322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9323     return 0;
9324   }
9325   {
9326     try {
9327       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9328     } catch (std::out_of_range& e) {
9329       {
9330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (std::exception& e) {
9333       {
9334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (Dali::DaliException e) {
9337       {
9338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9339       };
9340     } catch (...) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9343       };
9344     }
9345   }
9346
9347   jresult = (void *)result;
9348   return jresult;
9349 }
9350
9351
9352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9353   unsigned int jresult ;
9354   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9355   Dali::Uint16Pair *arg2 = 0 ;
9356   bool result;
9357
9358   arg1 = (Dali::Uint16Pair *)jarg1;
9359   arg2 = (Dali::Uint16Pair *)jarg2;
9360   if (!arg2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9362     return 0;
9363   }
9364   {
9365     try {
9366       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9367     } catch (std::out_of_range& e) {
9368       {
9369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9370       };
9371     } catch (std::exception& e) {
9372       {
9373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (Dali::DaliException e) {
9376       {
9377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9378       };
9379     } catch (...) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9382       };
9383     }
9384   }
9385
9386   jresult = result;
9387   return jresult;
9388 }
9389
9390
9391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9392   unsigned int jresult ;
9393   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9394   Dali::Uint16Pair *arg2 = 0 ;
9395   bool result;
9396
9397   arg1 = (Dali::Uint16Pair *)jarg1;
9398   arg2 = (Dali::Uint16Pair *)jarg2;
9399   if (!arg2) {
9400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9401     return 0;
9402   }
9403   {
9404     try {
9405       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9406     } catch (std::out_of_range& e) {
9407       {
9408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9409       };
9410     } catch (std::exception& e) {
9411       {
9412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (Dali::DaliException e) {
9415       {
9416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424
9425   jresult = result;
9426   return jresult;
9427 }
9428
9429
9430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9431   unsigned int jresult ;
9432   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9433   Dali::Uint16Pair *arg2 = 0 ;
9434   bool result;
9435
9436   arg1 = (Dali::Uint16Pair *)jarg1;
9437   arg2 = (Dali::Uint16Pair *)jarg2;
9438   if (!arg2) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9440     return 0;
9441   }
9442   {
9443     try {
9444       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9445     } catch (std::out_of_range& e) {
9446       {
9447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9448       };
9449     } catch (std::exception& e) {
9450       {
9451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (Dali::DaliException e) {
9454       {
9455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9456       };
9457     } catch (...) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9460       };
9461     }
9462   }
9463
9464   jresult = result;
9465   return jresult;
9466 }
9467
9468
9469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9470   unsigned int jresult ;
9471   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9472   Dali::Uint16Pair *arg2 = 0 ;
9473   bool result;
9474
9475   arg1 = (Dali::Uint16Pair *)jarg1;
9476   arg2 = (Dali::Uint16Pair *)jarg2;
9477   if (!arg2) {
9478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9479     return 0;
9480   }
9481   {
9482     try {
9483       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9484     } catch (std::out_of_range& e) {
9485       {
9486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9487       };
9488     } catch (std::exception& e) {
9489       {
9490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (Dali::DaliException e) {
9493       {
9494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9495       };
9496     } catch (...) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9499       };
9500     }
9501   }
9502
9503   jresult = result;
9504   return jresult;
9505 }
9506
9507
9508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9509   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9510
9511   arg1 = (Dali::Uint16Pair *)jarg1;
9512   {
9513     try {
9514       delete arg1;
9515     } catch (std::out_of_range& e) {
9516       {
9517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9518       };
9519     } catch (std::exception& e) {
9520       {
9521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (Dali::DaliException e) {
9524       {
9525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9526       };
9527     } catch (...) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9530       };
9531     }
9532   }
9533
9534 }
9535
9536
9537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9538   void * jresult ;
9539   Dali::Degree *result = 0 ;
9540
9541   {
9542     try {
9543       result = (Dali::Degree *)new Dali::Degree();
9544     } catch (std::out_of_range& e) {
9545       {
9546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9547       };
9548     } catch (std::exception& e) {
9549       {
9550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (Dali::DaliException e) {
9553       {
9554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9555       };
9556     } catch (...) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9559       };
9560     }
9561   }
9562
9563   jresult = (void *)result;
9564   return jresult;
9565 }
9566
9567
9568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9569   void * jresult ;
9570   float arg1 ;
9571   Dali::Degree *result = 0 ;
9572
9573   arg1 = (float)jarg1;
9574   {
9575     try {
9576       result = (Dali::Degree *)new Dali::Degree(arg1);
9577     } catch (std::out_of_range& e) {
9578       {
9579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9580       };
9581     } catch (std::exception& e) {
9582       {
9583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (Dali::DaliException e) {
9586       {
9587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9588       };
9589     } catch (...) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9592       };
9593     }
9594   }
9595
9596   jresult = (void *)result;
9597   return jresult;
9598 }
9599
9600
9601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9602   void * jresult ;
9603   Dali::Radian arg1 ;
9604   Dali::Radian *argp1 ;
9605   Dali::Degree *result = 0 ;
9606
9607   argp1 = (Dali::Radian *)jarg1;
9608   if (!argp1) {
9609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9610     return 0;
9611   }
9612   arg1 = *argp1;
9613   {
9614     try {
9615       result = (Dali::Degree *)new Dali::Degree(arg1);
9616     } catch (std::out_of_range& e) {
9617       {
9618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9619       };
9620     } catch (std::exception& e) {
9621       {
9622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (Dali::DaliException e) {
9625       {
9626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9627       };
9628     } catch (...) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9631       };
9632     }
9633   }
9634
9635   jresult = (void *)result;
9636   return jresult;
9637 }
9638
9639
9640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9641   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9642   float arg2 ;
9643
9644   arg1 = (Dali::Degree *)jarg1;
9645   arg2 = (float)jarg2;
9646   if (arg1) (arg1)->degree = arg2;
9647 }
9648
9649
9650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9651   float jresult ;
9652   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9653   float result;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   result = (float) ((arg1)->degree);
9657   jresult = result;
9658   return jresult;
9659 }
9660
9661
9662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9663   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9664
9665   arg1 = (Dali::Degree *)jarg1;
9666   {
9667     try {
9668       delete arg1;
9669     } catch (std::out_of_range& e) {
9670       {
9671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9672       };
9673     } catch (std::exception& e) {
9674       {
9675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (Dali::DaliException e) {
9678       {
9679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9680       };
9681     } catch (...) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9684       };
9685     }
9686   }
9687
9688 }
9689
9690
9691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9692   void * jresult ;
9693   Dali::Radian *result = 0 ;
9694
9695   result = (Dali::Radian *)&Dali::ANGLE_360;
9696   jresult = (void *)result;
9697   return jresult;
9698 }
9699
9700
9701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9702   void * jresult ;
9703   Dali::Radian *result = 0 ;
9704
9705   result = (Dali::Radian *)&Dali::ANGLE_315;
9706   jresult = (void *)result;
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9712   void * jresult ;
9713   Dali::Radian *result = 0 ;
9714
9715   result = (Dali::Radian *)&Dali::ANGLE_270;
9716   jresult = (void *)result;
9717   return jresult;
9718 }
9719
9720
9721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9722   void * jresult ;
9723   Dali::Radian *result = 0 ;
9724
9725   result = (Dali::Radian *)&Dali::ANGLE_225;
9726   jresult = (void *)result;
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9732   void * jresult ;
9733   Dali::Radian *result = 0 ;
9734
9735   result = (Dali::Radian *)&Dali::ANGLE_180;
9736   jresult = (void *)result;
9737   return jresult;
9738 }
9739
9740
9741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9742   void * jresult ;
9743   Dali::Radian *result = 0 ;
9744
9745   result = (Dali::Radian *)&Dali::ANGLE_135;
9746   jresult = (void *)result;
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9752   void * jresult ;
9753   Dali::Radian *result = 0 ;
9754
9755   result = (Dali::Radian *)&Dali::ANGLE_120;
9756   jresult = (void *)result;
9757   return jresult;
9758 }
9759
9760
9761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9762   void * jresult ;
9763   Dali::Radian *result = 0 ;
9764
9765   result = (Dali::Radian *)&Dali::ANGLE_90;
9766   jresult = (void *)result;
9767   return jresult;
9768 }
9769
9770
9771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9772   void * jresult ;
9773   Dali::Radian *result = 0 ;
9774
9775   result = (Dali::Radian *)&Dali::ANGLE_60;
9776   jresult = (void *)result;
9777   return jresult;
9778 }
9779
9780
9781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9782   void * jresult ;
9783   Dali::Radian *result = 0 ;
9784
9785   result = (Dali::Radian *)&Dali::ANGLE_45;
9786   jresult = (void *)result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9792   void * jresult ;
9793   Dali::Radian *result = 0 ;
9794
9795   result = (Dali::Radian *)&Dali::ANGLE_30;
9796   jresult = (void *)result;
9797   return jresult;
9798 }
9799
9800
9801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9802   void * jresult ;
9803   Dali::Radian *result = 0 ;
9804
9805   result = (Dali::Radian *)&Dali::ANGLE_0;
9806   jresult = (void *)result;
9807   return jresult;
9808 }
9809
9810
9811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9812   unsigned int jresult ;
9813   Dali::Degree *arg1 = 0 ;
9814   Dali::Degree *arg2 = 0 ;
9815   bool result;
9816
9817   arg1 = (Dali::Degree *)jarg1;
9818   if (!arg1) {
9819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9820     return 0;
9821   }
9822   arg2 = (Dali::Degree *)jarg2;
9823   if (!arg2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9825     return 0;
9826   }
9827   {
9828     try {
9829       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9830     } catch (std::out_of_range& e) {
9831       {
9832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9833       };
9834     } catch (std::exception& e) {
9835       {
9836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (Dali::DaliException e) {
9839       {
9840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9841       };
9842     } catch (...) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9845       };
9846     }
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9855   unsigned int jresult ;
9856   Dali::Degree *arg1 = 0 ;
9857   Dali::Degree *arg2 = 0 ;
9858   bool result;
9859
9860   arg1 = (Dali::Degree *)jarg1;
9861   if (!arg1) {
9862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9863     return 0;
9864   }
9865   arg2 = (Dali::Degree *)jarg2;
9866   if (!arg2) {
9867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9868     return 0;
9869   }
9870   {
9871     try {
9872       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9873     } catch (std::out_of_range& e) {
9874       {
9875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (std::exception& e) {
9878       {
9879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (Dali::DaliException e) {
9882       {
9883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9884       };
9885     } catch (...) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9888       };
9889     }
9890   }
9891
9892   jresult = result;
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9898   void * jresult ;
9899   Dali::Degree arg1 ;
9900   float arg2 ;
9901   float arg3 ;
9902   Dali::Degree *argp1 ;
9903   Dali::Degree result;
9904
9905   argp1 = (Dali::Degree *)jarg1;
9906   if (!argp1) {
9907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9908     return 0;
9909   }
9910   arg1 = *argp1;
9911   arg2 = (float)jarg2;
9912   arg3 = (float)jarg3;
9913   {
9914     try {
9915       result = Dali::Clamp(arg1,arg2,arg3);
9916     } catch (std::out_of_range& e) {
9917       {
9918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9919       };
9920     } catch (std::exception& e) {
9921       {
9922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (Dali::DaliException e) {
9925       {
9926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9927       };
9928     } catch (...) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9931       };
9932     }
9933   }
9934
9935   jresult = new Dali::Degree((const Dali::Degree &)result);
9936   return jresult;
9937 }
9938
9939
9940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9941   void * jresult ;
9942   Dali::Radian *result = 0 ;
9943
9944   {
9945     try {
9946       result = (Dali::Radian *)new Dali::Radian();
9947     } catch (std::out_of_range& e) {
9948       {
9949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9950       };
9951     } catch (std::exception& e) {
9952       {
9953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (Dali::DaliException e) {
9956       {
9957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9958       };
9959     } catch (...) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9962       };
9963     }
9964   }
9965
9966   jresult = (void *)result;
9967   return jresult;
9968 }
9969
9970
9971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9972   void * jresult ;
9973   float arg1 ;
9974   Dali::Radian *result = 0 ;
9975
9976   arg1 = (float)jarg1;
9977   {
9978     try {
9979       result = (Dali::Radian *)new Dali::Radian(arg1);
9980     } catch (std::out_of_range& e) {
9981       {
9982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9983       };
9984     } catch (std::exception& e) {
9985       {
9986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (Dali::DaliException e) {
9989       {
9990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9991       };
9992     } catch (...) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9995       };
9996     }
9997   }
9998
9999   jresult = (void *)result;
10000   return jresult;
10001 }
10002
10003
10004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10005   void * jresult ;
10006   Dali::Degree arg1 ;
10007   Dali::Degree *argp1 ;
10008   Dali::Radian *result = 0 ;
10009
10010   argp1 = (Dali::Degree *)jarg1;
10011   if (!argp1) {
10012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10013     return 0;
10014   }
10015   arg1 = *argp1;
10016   {
10017     try {
10018       result = (Dali::Radian *)new Dali::Radian(arg1);
10019     } catch (std::out_of_range& e) {
10020       {
10021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10022       };
10023     } catch (std::exception& e) {
10024       {
10025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (Dali::DaliException e) {
10028       {
10029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10030       };
10031     } catch (...) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10034       };
10035     }
10036   }
10037
10038   jresult = (void *)result;
10039   return jresult;
10040 }
10041
10042
10043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10044   void * jresult ;
10045   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10046   float arg2 ;
10047   Dali::Radian *result = 0 ;
10048
10049   arg1 = (Dali::Radian *)jarg1;
10050   arg2 = (float)jarg2;
10051   {
10052     try {
10053       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (Dali::DaliException e) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10065       };
10066     } catch (...) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10069       };
10070     }
10071   }
10072
10073   jresult = (void *)result;
10074   return jresult;
10075 }
10076
10077
10078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10079   void * jresult ;
10080   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10081   Dali::Degree arg2 ;
10082   Dali::Degree *argp2 ;
10083   Dali::Radian *result = 0 ;
10084
10085   arg1 = (Dali::Radian *)jarg1;
10086   argp2 = (Dali::Degree *)jarg2;
10087   if (!argp2) {
10088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10089     return 0;
10090   }
10091   arg2 = *argp2;
10092   {
10093     try {
10094       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10095     } catch (std::out_of_range& e) {
10096       {
10097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10098       };
10099     } catch (std::exception& e) {
10100       {
10101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (Dali::DaliException e) {
10104       {
10105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10106       };
10107     } catch (...) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10110       };
10111     }
10112   }
10113
10114   jresult = (void *)result;
10115   return jresult;
10116 }
10117
10118
10119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10120   float jresult ;
10121   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10122   float result;
10123
10124   arg1 = (Dali::Radian *)jarg1;
10125   {
10126     try {
10127       result = (float)((Dali::Radian const *)arg1)->operator float();
10128     } catch (std::out_of_range& e) {
10129       {
10130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10131       };
10132     } catch (std::exception& e) {
10133       {
10134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (Dali::DaliException e) {
10137       {
10138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10139       };
10140     } catch (...) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10143       };
10144     }
10145   }
10146
10147   jresult = result;
10148   return jresult;
10149 }
10150
10151
10152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10153   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10154   float arg2 ;
10155
10156   arg1 = (Dali::Radian *)jarg1;
10157   arg2 = (float)jarg2;
10158   if (arg1) (arg1)->radian = arg2;
10159 }
10160
10161
10162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10163   float jresult ;
10164   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10165   float result;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   result = (float) ((arg1)->radian);
10169   jresult = result;
10170   return jresult;
10171 }
10172
10173
10174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10175   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10176
10177   arg1 = (Dali::Radian *)jarg1;
10178   {
10179     try {
10180       delete arg1;
10181     } catch (std::out_of_range& e) {
10182       {
10183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10184       };
10185     } catch (std::exception& e) {
10186       {
10187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (Dali::DaliException e) {
10190       {
10191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10192       };
10193     } catch (...) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10196       };
10197     }
10198   }
10199
10200 }
10201
10202
10203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10204   unsigned int jresult ;
10205   Dali::Radian arg1 ;
10206   Dali::Radian arg2 ;
10207   Dali::Radian *argp1 ;
10208   Dali::Radian *argp2 ;
10209   bool result;
10210
10211   argp1 = (Dali::Radian *)jarg1;
10212   if (!argp1) {
10213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10214     return 0;
10215   }
10216   arg1 = *argp1;
10217   argp2 = (Dali::Radian *)jarg2;
10218   if (!argp2) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg2 = *argp2;
10223   {
10224     try {
10225       result = (bool)Dali::operator ==(arg1,arg2);
10226     } catch (std::out_of_range& e) {
10227       {
10228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10229       };
10230     } catch (std::exception& e) {
10231       {
10232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (Dali::DaliException e) {
10235       {
10236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10237       };
10238     } catch (...) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10241       };
10242     }
10243   }
10244
10245   jresult = result;
10246   return jresult;
10247 }
10248
10249
10250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10251   unsigned int jresult ;
10252   Dali::Radian arg1 ;
10253   Dali::Radian arg2 ;
10254   Dali::Radian *argp1 ;
10255   Dali::Radian *argp2 ;
10256   bool result;
10257
10258   argp1 = (Dali::Radian *)jarg1;
10259   if (!argp1) {
10260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10261     return 0;
10262   }
10263   arg1 = *argp1;
10264   argp2 = (Dali::Radian *)jarg2;
10265   if (!argp2) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg2 = *argp2;
10270   {
10271     try {
10272       result = (bool)Dali::operator !=(arg1,arg2);
10273     } catch (std::out_of_range& e) {
10274       {
10275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10276       };
10277     } catch (std::exception& e) {
10278       {
10279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (Dali::DaliException e) {
10282       {
10283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10284       };
10285     } catch (...) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10288       };
10289     }
10290   }
10291
10292   jresult = result;
10293   return jresult;
10294 }
10295
10296
10297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10298   unsigned int jresult ;
10299   Dali::Radian arg1 ;
10300   Dali::Degree arg2 ;
10301   Dali::Radian *argp1 ;
10302   Dali::Degree *argp2 ;
10303   bool result;
10304
10305   argp1 = (Dali::Radian *)jarg1;
10306   if (!argp1) {
10307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10308     return 0;
10309   }
10310   arg1 = *argp1;
10311   argp2 = (Dali::Degree *)jarg2;
10312   if (!argp2) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10314     return 0;
10315   }
10316   arg2 = *argp2;
10317   {
10318     try {
10319       result = (bool)Dali::operator ==(arg1,arg2);
10320     } catch (std::out_of_range& e) {
10321       {
10322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10323       };
10324     } catch (std::exception& e) {
10325       {
10326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (Dali::DaliException e) {
10329       {
10330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10331       };
10332     } catch (...) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10335       };
10336     }
10337   }
10338
10339   jresult = result;
10340   return jresult;
10341 }
10342
10343
10344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10345   unsigned int jresult ;
10346   Dali::Radian arg1 ;
10347   Dali::Degree arg2 ;
10348   Dali::Radian *argp1 ;
10349   Dali::Degree *argp2 ;
10350   bool result;
10351
10352   argp1 = (Dali::Radian *)jarg1;
10353   if (!argp1) {
10354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10355     return 0;
10356   }
10357   arg1 = *argp1;
10358   argp2 = (Dali::Degree *)jarg2;
10359   if (!argp2) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10361     return 0;
10362   }
10363   arg2 = *argp2;
10364   {
10365     try {
10366       result = (bool)Dali::operator !=(arg1,arg2);
10367     } catch (std::out_of_range& e) {
10368       {
10369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10370       };
10371     } catch (std::exception& e) {
10372       {
10373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (Dali::DaliException e) {
10376       {
10377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10378       };
10379     } catch (...) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10382       };
10383     }
10384   }
10385
10386   jresult = result;
10387   return jresult;
10388 }
10389
10390
10391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10392   unsigned int jresult ;
10393   Dali::Degree arg1 ;
10394   Dali::Radian arg2 ;
10395   Dali::Degree *argp1 ;
10396   Dali::Radian *argp2 ;
10397   bool result;
10398
10399   argp1 = (Dali::Degree *)jarg1;
10400   if (!argp1) {
10401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10402     return 0;
10403   }
10404   arg1 = *argp1;
10405   argp2 = (Dali::Radian *)jarg2;
10406   if (!argp2) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10408     return 0;
10409   }
10410   arg2 = *argp2;
10411   {
10412     try {
10413       result = (bool)Dali::operator ==(arg1,arg2);
10414     } catch (std::out_of_range& e) {
10415       {
10416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10417       };
10418     } catch (std::exception& e) {
10419       {
10420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (Dali::DaliException e) {
10423       {
10424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10425       };
10426     } catch (...) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10429       };
10430     }
10431   }
10432
10433   jresult = result;
10434   return jresult;
10435 }
10436
10437
10438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10439   unsigned int jresult ;
10440   Dali::Degree arg1 ;
10441   Dali::Radian arg2 ;
10442   Dali::Degree *argp1 ;
10443   Dali::Radian *argp2 ;
10444   bool result;
10445
10446   argp1 = (Dali::Degree *)jarg1;
10447   if (!argp1) {
10448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10449     return 0;
10450   }
10451   arg1 = *argp1;
10452   argp2 = (Dali::Radian *)jarg2;
10453   if (!argp2) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10455     return 0;
10456   }
10457   arg2 = *argp2;
10458   {
10459     try {
10460       result = (bool)Dali::operator !=(arg1,arg2);
10461     } catch (std::out_of_range& e) {
10462       {
10463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10464       };
10465     } catch (std::exception& e) {
10466       {
10467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (Dali::DaliException e) {
10470       {
10471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10472       };
10473     } catch (...) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10476       };
10477     }
10478   }
10479
10480   jresult = result;
10481   return jresult;
10482 }
10483
10484
10485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10486   unsigned int jresult ;
10487   Dali::Radian arg1 ;
10488   Dali::Radian arg2 ;
10489   Dali::Radian *argp1 ;
10490   Dali::Radian *argp2 ;
10491   bool result;
10492
10493   argp1 = (Dali::Radian *)jarg1;
10494   if (!argp1) {
10495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10496     return 0;
10497   }
10498   arg1 = *argp1;
10499   argp2 = (Dali::Radian *)jarg2;
10500   if (!argp2) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg2 = *argp2;
10505   {
10506     try {
10507       result = (bool)Dali::operator >(arg1,arg2);
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (Dali::DaliException e) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10519       };
10520     } catch (...) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10523       };
10524     }
10525   }
10526
10527   jresult = result;
10528   return jresult;
10529 }
10530
10531
10532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10533   unsigned int jresult ;
10534   Dali::Radian arg1 ;
10535   Dali::Degree arg2 ;
10536   Dali::Radian *argp1 ;
10537   Dali::Degree *argp2 ;
10538   bool result;
10539
10540   argp1 = (Dali::Radian *)jarg1;
10541   if (!argp1) {
10542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10543     return 0;
10544   }
10545   arg1 = *argp1;
10546   argp2 = (Dali::Degree *)jarg2;
10547   if (!argp2) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10549     return 0;
10550   }
10551   arg2 = *argp2;
10552   {
10553     try {
10554       result = (bool)Dali::operator >(arg1,arg2);
10555     } catch (std::out_of_range& e) {
10556       {
10557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10558       };
10559     } catch (std::exception& e) {
10560       {
10561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (Dali::DaliException e) {
10564       {
10565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10566       };
10567     } catch (...) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10570       };
10571     }
10572   }
10573
10574   jresult = result;
10575   return jresult;
10576 }
10577
10578
10579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10580   unsigned int jresult ;
10581   Dali::Degree arg1 ;
10582   Dali::Radian arg2 ;
10583   Dali::Degree *argp1 ;
10584   Dali::Radian *argp2 ;
10585   bool result;
10586
10587   argp1 = (Dali::Degree *)jarg1;
10588   if (!argp1) {
10589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10590     return 0;
10591   }
10592   arg1 = *argp1;
10593   argp2 = (Dali::Radian *)jarg2;
10594   if (!argp2) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10596     return 0;
10597   }
10598   arg2 = *argp2;
10599   {
10600     try {
10601       result = (bool)Dali::operator >(arg1,arg2);
10602     } catch (std::out_of_range& e) {
10603       {
10604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10605       };
10606     } catch (std::exception& e) {
10607       {
10608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (Dali::DaliException e) {
10611       {
10612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10613       };
10614     } catch (...) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10617       };
10618     }
10619   }
10620
10621   jresult = result;
10622   return jresult;
10623 }
10624
10625
10626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10627   unsigned int jresult ;
10628   Dali::Radian arg1 ;
10629   Dali::Radian arg2 ;
10630   Dali::Radian *argp1 ;
10631   Dali::Radian *argp2 ;
10632   bool result;
10633
10634   argp1 = (Dali::Radian *)jarg1;
10635   if (!argp1) {
10636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10637     return 0;
10638   }
10639   arg1 = *argp1;
10640   argp2 = (Dali::Radian *)jarg2;
10641   if (!argp2) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg2 = *argp2;
10646   {
10647     try {
10648       result = (bool)Dali::operator <(arg1,arg2);
10649     } catch (std::out_of_range& e) {
10650       {
10651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10652       };
10653     } catch (std::exception& e) {
10654       {
10655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (Dali::DaliException e) {
10658       {
10659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10660       };
10661     } catch (...) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10664       };
10665     }
10666   }
10667
10668   jresult = result;
10669   return jresult;
10670 }
10671
10672
10673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10674   unsigned int jresult ;
10675   Dali::Radian arg1 ;
10676   Dali::Degree arg2 ;
10677   Dali::Radian *argp1 ;
10678   Dali::Degree *argp2 ;
10679   bool result;
10680
10681   argp1 = (Dali::Radian *)jarg1;
10682   if (!argp1) {
10683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10684     return 0;
10685   }
10686   arg1 = *argp1;
10687   argp2 = (Dali::Degree *)jarg2;
10688   if (!argp2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10690     return 0;
10691   }
10692   arg2 = *argp2;
10693   {
10694     try {
10695       result = (bool)Dali::operator <(arg1,arg2);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (Dali::DaliException e) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10707       };
10708     } catch (...) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10711       };
10712     }
10713   }
10714
10715   jresult = result;
10716   return jresult;
10717 }
10718
10719
10720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10721   unsigned int jresult ;
10722   Dali::Degree arg1 ;
10723   Dali::Radian arg2 ;
10724   Dali::Degree *argp1 ;
10725   Dali::Radian *argp2 ;
10726   bool result;
10727
10728   argp1 = (Dali::Degree *)jarg1;
10729   if (!argp1) {
10730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10731     return 0;
10732   }
10733   arg1 = *argp1;
10734   argp2 = (Dali::Radian *)jarg2;
10735   if (!argp2) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10737     return 0;
10738   }
10739   arg2 = *argp2;
10740   {
10741     try {
10742       result = (bool)Dali::operator <(arg1,arg2);
10743     } catch (std::out_of_range& e) {
10744       {
10745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10746       };
10747     } catch (std::exception& e) {
10748       {
10749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (Dali::DaliException e) {
10752       {
10753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10754       };
10755     } catch (...) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10758       };
10759     }
10760   }
10761
10762   jresult = result;
10763   return jresult;
10764 }
10765
10766
10767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10768   void * jresult ;
10769   Dali::Radian arg1 ;
10770   float arg2 ;
10771   Dali::Radian *argp1 ;
10772   Dali::Radian result;
10773
10774   argp1 = (Dali::Radian *)jarg1;
10775   if (!argp1) {
10776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10777     return 0;
10778   }
10779   arg1 = *argp1;
10780   arg2 = (float)jarg2;
10781   {
10782     try {
10783       result = Dali::operator *(arg1,arg2);
10784     } catch (std::out_of_range& e) {
10785       {
10786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10787       };
10788     } catch (std::exception& e) {
10789       {
10790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (Dali::DaliException e) {
10793       {
10794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10795       };
10796     } catch (...) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10799       };
10800     }
10801   }
10802
10803   jresult = new Dali::Radian((const Dali::Radian &)result);
10804   return jresult;
10805 }
10806
10807
10808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10809   void * jresult ;
10810   Dali::Radian arg1 ;
10811   Dali::Radian *argp1 ;
10812   Dali::Radian result;
10813
10814   argp1 = (Dali::Radian *)jarg1;
10815   if (!argp1) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10817     return 0;
10818   }
10819   arg1 = *argp1;
10820   {
10821     try {
10822       result = Dali::operator -(arg1);
10823     } catch (std::out_of_range& e) {
10824       {
10825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10826       };
10827     } catch (std::exception& e) {
10828       {
10829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (Dali::DaliException e) {
10832       {
10833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10834       };
10835     } catch (...) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10838       };
10839     }
10840   }
10841
10842   jresult = new Dali::Radian((const Dali::Radian &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10848   void * jresult ;
10849   Dali::Radian arg1 ;
10850   float arg2 ;
10851   float arg3 ;
10852   Dali::Radian *argp1 ;
10853   Dali::Radian result;
10854
10855   argp1 = (Dali::Radian *)jarg1;
10856   if (!argp1) {
10857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10858     return 0;
10859   }
10860   arg1 = *argp1;
10861   arg2 = (float)jarg2;
10862   arg3 = (float)jarg3;
10863   {
10864     try {
10865       result = Dali::Clamp(arg1,arg2,arg3);
10866     } catch (std::out_of_range& e) {
10867       {
10868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (std::exception& e) {
10871       {
10872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (Dali::DaliException e) {
10875       {
10876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10877       };
10878     } catch (...) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10881       };
10882     }
10883   }
10884
10885   jresult = new Dali::Radian((const Dali::Radian &)result);
10886   return jresult;
10887 }
10888
10889
10890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10891   void * jresult ;
10892   Dali::Quaternion *result = 0 ;
10893
10894   {
10895     try {
10896       result = (Dali::Quaternion *)new Dali::Quaternion();
10897     } catch (std::out_of_range& e) {
10898       {
10899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10900       };
10901     } catch (std::exception& e) {
10902       {
10903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (Dali::DaliException e) {
10906       {
10907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10908       };
10909     } catch (...) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10912       };
10913     }
10914   }
10915
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10922   void * jresult ;
10923   Dali::Radian arg1 ;
10924   Dali::Vector3 *arg2 = 0 ;
10925   Dali::Radian *argp1 ;
10926   Dali::Quaternion *result = 0 ;
10927
10928   argp1 = (Dali::Radian *)jarg1;
10929   if (!argp1) {
10930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10931     return 0;
10932   }
10933   arg1 = *argp1;
10934   arg2 = (Dali::Vector3 *)jarg2;
10935   if (!arg2) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10937     return 0;
10938   }
10939   {
10940     try {
10941       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10942     } catch (std::out_of_range& e) {
10943       {
10944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10945       };
10946     } catch (std::exception& e) {
10947       {
10948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (Dali::DaliException e) {
10951       {
10952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10953       };
10954     } catch (...) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10957       };
10958     }
10959   }
10960
10961   jresult = (void *)result;
10962   return jresult;
10963 }
10964
10965
10966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10967   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10968
10969   arg1 = (Dali::Quaternion *)jarg1;
10970   {
10971     try {
10972       delete arg1;
10973     } catch (std::out_of_range& e) {
10974       {
10975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10976       };
10977     } catch (std::exception& e) {
10978       {
10979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (Dali::DaliException e) {
10982       {
10983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10984       };
10985     } catch (...) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10988       };
10989     }
10990   }
10991
10992 }
10993
10994
10995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10996   void * jresult ;
10997   Dali::Quaternion *result = 0 ;
10998
10999   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11000   jresult = (void *)result;
11001   return jresult;
11002 }
11003
11004
11005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11006   unsigned int jresult ;
11007   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11008   bool result;
11009
11010   arg1 = (Dali::Quaternion *)jarg1;
11011   {
11012     try {
11013       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11014     } catch (std::out_of_range& e) {
11015       {
11016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (std::exception& e) {
11019       {
11020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (Dali::DaliException e) {
11023       {
11024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11025       };
11026     } catch (...) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11029       };
11030     }
11031   }
11032
11033   jresult = result;
11034   return jresult;
11035 }
11036
11037
11038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11039   unsigned int jresult ;
11040   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11041   Dali::Vector3 *arg2 = 0 ;
11042   Dali::Radian *arg3 = 0 ;
11043   bool result;
11044
11045   arg1 = (Dali::Quaternion *)jarg1;
11046   arg2 = (Dali::Vector3 *)jarg2;
11047   if (!arg2) {
11048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11049     return 0;
11050   }
11051   arg3 = (Dali::Radian *)jarg3;
11052   if (!arg3) {
11053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11054     return 0;
11055   }
11056   {
11057     try {
11058       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11059     } catch (std::out_of_range& e) {
11060       {
11061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11062       };
11063     } catch (std::exception& e) {
11064       {
11065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (Dali::DaliException e) {
11068       {
11069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11070       };
11071     } catch (...) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11074       };
11075     }
11076   }
11077
11078   jresult = result;
11079   return jresult;
11080 }
11081
11082
11083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11084   void * jresult ;
11085   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11086   Dali::Quaternion *arg2 = 0 ;
11087   Dali::Quaternion result;
11088
11089   arg1 = (Dali::Quaternion *)jarg1;
11090   arg2 = (Dali::Quaternion *)jarg2;
11091   if (!arg2) {
11092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11093     return 0;
11094   }
11095   {
11096     try {
11097       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11098     } catch (std::out_of_range& e) {
11099       {
11100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11101       };
11102     } catch (std::exception& e) {
11103       {
11104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (Dali::DaliException e) {
11107       {
11108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11109       };
11110     } catch (...) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11113       };
11114     }
11115   }
11116
11117   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11118   return jresult;
11119 }
11120
11121
11122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11123   void * jresult ;
11124   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11125   Dali::Quaternion *arg2 = 0 ;
11126   Dali::Quaternion result;
11127
11128   arg1 = (Dali::Quaternion *)jarg1;
11129   arg2 = (Dali::Quaternion *)jarg2;
11130   if (!arg2) {
11131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11132     return 0;
11133   }
11134   {
11135     try {
11136       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11137     } catch (std::out_of_range& e) {
11138       {
11139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11140       };
11141     } catch (std::exception& e) {
11142       {
11143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (Dali::DaliException e) {
11146       {
11147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11148       };
11149     } catch (...) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11152       };
11153     }
11154   }
11155
11156   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11157   return jresult;
11158 }
11159
11160
11161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11162   void * jresult ;
11163   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11164   Dali::Quaternion *arg2 = 0 ;
11165   Dali::Quaternion result;
11166
11167   arg1 = (Dali::Quaternion *)jarg1;
11168   arg2 = (Dali::Quaternion *)jarg2;
11169   if (!arg2) {
11170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11171     return 0;
11172   }
11173   {
11174     try {
11175       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11176     } catch (std::out_of_range& e) {
11177       {
11178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11179       };
11180     } catch (std::exception& e) {
11181       {
11182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (Dali::DaliException e) {
11185       {
11186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11187       };
11188     } catch (...) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11191       };
11192     }
11193   }
11194
11195   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11196   return jresult;
11197 }
11198
11199
11200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11201   void * jresult ;
11202   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11203   Dali::Vector3 *arg2 = 0 ;
11204   Dali::Vector3 result;
11205
11206   arg1 = (Dali::Quaternion *)jarg1;
11207   arg2 = (Dali::Vector3 *)jarg2;
11208   if (!arg2) {
11209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11210     return 0;
11211   }
11212   {
11213     try {
11214       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (Dali::DaliException e) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11226       };
11227     } catch (...) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11230       };
11231     }
11232   }
11233
11234   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11235   return jresult;
11236 }
11237
11238
11239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11240   void * jresult ;
11241   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11242   Dali::Quaternion *arg2 = 0 ;
11243   Dali::Quaternion result;
11244
11245   arg1 = (Dali::Quaternion *)jarg1;
11246   arg2 = (Dali::Quaternion *)jarg2;
11247   if (!arg2) {
11248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11249     return 0;
11250   }
11251   {
11252     try {
11253       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11254     } catch (std::out_of_range& e) {
11255       {
11256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11257       };
11258     } catch (std::exception& e) {
11259       {
11260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (Dali::DaliException e) {
11263       {
11264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11265       };
11266     } catch (...) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11269       };
11270     }
11271   }
11272
11273   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11274   return jresult;
11275 }
11276
11277
11278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11279   void * jresult ;
11280   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11281   float arg2 ;
11282   Dali::Quaternion result;
11283
11284   arg1 = (Dali::Quaternion *)jarg1;
11285   arg2 = (float)jarg2;
11286   {
11287     try {
11288       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11289     } catch (std::out_of_range& e) {
11290       {
11291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11292       };
11293     } catch (std::exception& e) {
11294       {
11295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (Dali::DaliException e) {
11298       {
11299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11300       };
11301     } catch (...) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11304       };
11305     }
11306   }
11307
11308   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11309   return jresult;
11310 }
11311
11312
11313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11314   void * jresult ;
11315   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11316   float arg2 ;
11317   Dali::Quaternion result;
11318
11319   arg1 = (Dali::Quaternion *)jarg1;
11320   arg2 = (float)jarg2;
11321   {
11322     try {
11323       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11324     } catch (std::out_of_range& e) {
11325       {
11326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11327       };
11328     } catch (std::exception& e) {
11329       {
11330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (Dali::DaliException e) {
11333       {
11334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11335       };
11336     } catch (...) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11339       };
11340     }
11341   }
11342
11343   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11344   return jresult;
11345 }
11346
11347
11348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11349   void * jresult ;
11350   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11351   Dali::Quaternion result;
11352
11353   arg1 = (Dali::Quaternion *)jarg1;
11354   {
11355     try {
11356       result = ((Dali::Quaternion const *)arg1)->operator -();
11357     } catch (std::out_of_range& e) {
11358       {
11359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11360       };
11361     } catch (std::exception& e) {
11362       {
11363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (Dali::DaliException e) {
11366       {
11367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11368       };
11369     } catch (...) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11372       };
11373     }
11374   }
11375
11376   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11377   return jresult;
11378 }
11379
11380
11381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11382   void * jresult ;
11383   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11384   Dali::Quaternion *arg2 = 0 ;
11385   Dali::Quaternion *result = 0 ;
11386
11387   arg1 = (Dali::Quaternion *)jarg1;
11388   arg2 = (Dali::Quaternion *)jarg2;
11389   if (!arg2) {
11390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11391     return 0;
11392   }
11393   {
11394     try {
11395       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11396     } catch (std::out_of_range& e) {
11397       {
11398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (std::exception& e) {
11401       {
11402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (Dali::DaliException e) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11407       };
11408     } catch (...) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11411       };
11412     }
11413   }
11414
11415   jresult = (void *)result;
11416   return jresult;
11417 }
11418
11419
11420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11421   void * jresult ;
11422   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11423   Dali::Quaternion *arg2 = 0 ;
11424   Dali::Quaternion *result = 0 ;
11425
11426   arg1 = (Dali::Quaternion *)jarg1;
11427   arg2 = (Dali::Quaternion *)jarg2;
11428   if (!arg2) {
11429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11430     return 0;
11431   }
11432   {
11433     try {
11434       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11435     } catch (std::out_of_range& e) {
11436       {
11437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11438       };
11439     } catch (std::exception& e) {
11440       {
11441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (Dali::DaliException e) {
11444       {
11445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11446       };
11447     } catch (...) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11450       };
11451     }
11452   }
11453
11454   jresult = (void *)result;
11455   return jresult;
11456 }
11457
11458
11459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11460   void * jresult ;
11461   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11462   Dali::Quaternion *arg2 = 0 ;
11463   Dali::Quaternion *result = 0 ;
11464
11465   arg1 = (Dali::Quaternion *)jarg1;
11466   arg2 = (Dali::Quaternion *)jarg2;
11467   if (!arg2) {
11468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11469     return 0;
11470   }
11471   {
11472     try {
11473       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11474     } catch (std::out_of_range& e) {
11475       {
11476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11477       };
11478     } catch (std::exception& e) {
11479       {
11480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (Dali::DaliException e) {
11483       {
11484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11485       };
11486     } catch (...) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11489       };
11490     }
11491   }
11492
11493   jresult = (void *)result;
11494   return jresult;
11495 }
11496
11497
11498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11499   void * jresult ;
11500   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11501   float arg2 ;
11502   Dali::Quaternion *result = 0 ;
11503
11504   arg1 = (Dali::Quaternion *)jarg1;
11505   arg2 = (float)jarg2;
11506   {
11507     try {
11508       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11509     } catch (std::out_of_range& e) {
11510       {
11511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11512       };
11513     } catch (std::exception& e) {
11514       {
11515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (Dali::DaliException e) {
11518       {
11519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11520       };
11521     } catch (...) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11524       };
11525     }
11526   }
11527
11528   jresult = (void *)result;
11529   return jresult;
11530 }
11531
11532
11533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11534   void * jresult ;
11535   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11536   float arg2 ;
11537   Dali::Quaternion *result = 0 ;
11538
11539   arg1 = (Dali::Quaternion *)jarg1;
11540   arg2 = (float)jarg2;
11541   {
11542     try {
11543       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11544     } catch (std::out_of_range& e) {
11545       {
11546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11547       };
11548     } catch (std::exception& e) {
11549       {
11550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (Dali::DaliException e) {
11553       {
11554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11555       };
11556     } catch (...) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11559       };
11560     }
11561   }
11562
11563   jresult = (void *)result;
11564   return jresult;
11565 }
11566
11567
11568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11569   unsigned int jresult ;
11570   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11571   Dali::Quaternion *arg2 = 0 ;
11572   bool result;
11573
11574   arg1 = (Dali::Quaternion *)jarg1;
11575   arg2 = (Dali::Quaternion *)jarg2;
11576   if (!arg2) {
11577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11578     return 0;
11579   }
11580   {
11581     try {
11582       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11583     } catch (std::out_of_range& e) {
11584       {
11585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11586       };
11587     } catch (std::exception& e) {
11588       {
11589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (Dali::DaliException e) {
11592       {
11593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11594       };
11595     } catch (...) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11598       };
11599     }
11600   }
11601
11602   jresult = result;
11603   return jresult;
11604 }
11605
11606
11607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11608   unsigned int jresult ;
11609   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11610   Dali::Quaternion *arg2 = 0 ;
11611   bool result;
11612
11613   arg1 = (Dali::Quaternion *)jarg1;
11614   arg2 = (Dali::Quaternion *)jarg2;
11615   if (!arg2) {
11616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11617     return 0;
11618   }
11619   {
11620     try {
11621       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11622     } catch (std::out_of_range& e) {
11623       {
11624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11625       };
11626     } catch (std::exception& e) {
11627       {
11628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (Dali::DaliException e) {
11631       {
11632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11633       };
11634     } catch (...) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11637       };
11638     }
11639   }
11640
11641   jresult = result;
11642   return jresult;
11643 }
11644
11645
11646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11647   float jresult ;
11648   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11649   float result;
11650
11651   arg1 = (Dali::Quaternion *)jarg1;
11652   {
11653     try {
11654       result = (float)((Dali::Quaternion const *)arg1)->Length();
11655     } catch (std::out_of_range& e) {
11656       {
11657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11658       };
11659     } catch (std::exception& e) {
11660       {
11661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (Dali::DaliException e) {
11664       {
11665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11666       };
11667     } catch (...) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11670       };
11671     }
11672   }
11673
11674   jresult = result;
11675   return jresult;
11676 }
11677
11678
11679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11680   float jresult ;
11681   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11682   float result;
11683
11684   arg1 = (Dali::Quaternion *)jarg1;
11685   {
11686     try {
11687       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11688     } catch (std::out_of_range& e) {
11689       {
11690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11691       };
11692     } catch (std::exception& e) {
11693       {
11694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (Dali::DaliException e) {
11697       {
11698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11699       };
11700     } catch (...) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11703       };
11704     }
11705   }
11706
11707   jresult = result;
11708   return jresult;
11709 }
11710
11711
11712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11713   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11714
11715   arg1 = (Dali::Quaternion *)jarg1;
11716   {
11717     try {
11718       (arg1)->Normalize();
11719     } catch (std::out_of_range& e) {
11720       {
11721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11722       };
11723     } catch (std::exception& e) {
11724       {
11725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (Dali::DaliException e) {
11728       {
11729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11730       };
11731     } catch (...) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11734       };
11735     }
11736   }
11737
11738 }
11739
11740
11741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11742   void * jresult ;
11743   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11744   Dali::Quaternion result;
11745
11746   arg1 = (Dali::Quaternion *)jarg1;
11747   {
11748     try {
11749       result = ((Dali::Quaternion const *)arg1)->Normalized();
11750     } catch (std::out_of_range& e) {
11751       {
11752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11753       };
11754     } catch (std::exception& e) {
11755       {
11756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (Dali::DaliException e) {
11759       {
11760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11761       };
11762     } catch (...) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11765       };
11766     }
11767   }
11768
11769   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11770   return jresult;
11771 }
11772
11773
11774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11775   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11776
11777   arg1 = (Dali::Quaternion *)jarg1;
11778   {
11779     try {
11780       (arg1)->Conjugate();
11781     } catch (std::out_of_range& e) {
11782       {
11783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11784       };
11785     } catch (std::exception& e) {
11786       {
11787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (Dali::DaliException e) {
11790       {
11791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11792       };
11793     } catch (...) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11796       };
11797     }
11798   }
11799
11800 }
11801
11802
11803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11804   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11805
11806   arg1 = (Dali::Quaternion *)jarg1;
11807   {
11808     try {
11809       (arg1)->Invert();
11810     } catch (std::out_of_range& e) {
11811       {
11812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11813       };
11814     } catch (std::exception& e) {
11815       {
11816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (Dali::DaliException e) {
11819       {
11820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11821       };
11822     } catch (...) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11825       };
11826     }
11827   }
11828
11829 }
11830
11831
11832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11833   void * jresult ;
11834   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11835   Dali::Quaternion result;
11836
11837   arg1 = (Dali::Quaternion *)jarg1;
11838   {
11839     try {
11840       result = ((Dali::Quaternion const *)arg1)->Log();
11841     } catch (std::out_of_range& e) {
11842       {
11843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11844       };
11845     } catch (std::exception& e) {
11846       {
11847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (Dali::DaliException e) {
11850       {
11851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11852       };
11853     } catch (...) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11856       };
11857     }
11858   }
11859
11860   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11861   return jresult;
11862 }
11863
11864
11865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11866   void * jresult ;
11867   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11868   Dali::Quaternion result;
11869
11870   arg1 = (Dali::Quaternion *)jarg1;
11871   {
11872     try {
11873       result = ((Dali::Quaternion const *)arg1)->Exp();
11874     } catch (std::out_of_range& e) {
11875       {
11876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (std::exception& e) {
11879       {
11880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (Dali::DaliException e) {
11883       {
11884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11885       };
11886     } catch (...) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11889       };
11890     }
11891   }
11892
11893   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11894   return jresult;
11895 }
11896
11897
11898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11899   float jresult ;
11900   Dali::Quaternion *arg1 = 0 ;
11901   Dali::Quaternion *arg2 = 0 ;
11902   float result;
11903
11904   arg1 = (Dali::Quaternion *)jarg1;
11905   if (!arg1) {
11906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11907     return 0;
11908   }
11909   arg2 = (Dali::Quaternion *)jarg2;
11910   if (!arg2) {
11911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11912     return 0;
11913   }
11914   {
11915     try {
11916       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11917     } catch (std::out_of_range& e) {
11918       {
11919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11920       };
11921     } catch (std::exception& e) {
11922       {
11923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (Dali::DaliException e) {
11926       {
11927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935
11936   jresult = result;
11937   return jresult;
11938 }
11939
11940
11941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11942   void * jresult ;
11943   Dali::Quaternion *arg1 = 0 ;
11944   Dali::Quaternion *arg2 = 0 ;
11945   float arg3 ;
11946   Dali::Quaternion result;
11947
11948   arg1 = (Dali::Quaternion *)jarg1;
11949   if (!arg1) {
11950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11951     return 0;
11952   }
11953   arg2 = (Dali::Quaternion *)jarg2;
11954   if (!arg2) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11956     return 0;
11957   }
11958   arg3 = (float)jarg3;
11959   {
11960     try {
11961       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11962     } catch (std::out_of_range& e) {
11963       {
11964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11965       };
11966     } catch (std::exception& e) {
11967       {
11968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (Dali::DaliException e) {
11971       {
11972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11973       };
11974     } catch (...) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11977       };
11978     }
11979   }
11980
11981   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11982   return jresult;
11983 }
11984
11985
11986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11987   void * jresult ;
11988   Dali::Quaternion *arg1 = 0 ;
11989   Dali::Quaternion *arg2 = 0 ;
11990   float arg3 ;
11991   Dali::Quaternion result;
11992
11993   arg1 = (Dali::Quaternion *)jarg1;
11994   if (!arg1) {
11995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11996     return 0;
11997   }
11998   arg2 = (Dali::Quaternion *)jarg2;
11999   if (!arg2) {
12000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12001     return 0;
12002   }
12003   arg3 = (float)jarg3;
12004   {
12005     try {
12006       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12007     } catch (std::out_of_range& e) {
12008       {
12009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12010       };
12011     } catch (std::exception& e) {
12012       {
12013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (Dali::DaliException e) {
12016       {
12017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12018       };
12019     } catch (...) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12022       };
12023     }
12024   }
12025
12026   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12027   return jresult;
12028 }
12029
12030
12031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12032   void * jresult ;
12033   Dali::Quaternion *arg1 = 0 ;
12034   Dali::Quaternion *arg2 = 0 ;
12035   float arg3 ;
12036   Dali::Quaternion result;
12037
12038   arg1 = (Dali::Quaternion *)jarg1;
12039   if (!arg1) {
12040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12041     return 0;
12042   }
12043   arg2 = (Dali::Quaternion *)jarg2;
12044   if (!arg2) {
12045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12046     return 0;
12047   }
12048   arg3 = (float)jarg3;
12049   {
12050     try {
12051       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12052     } catch (std::out_of_range& e) {
12053       {
12054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12055       };
12056     } catch (std::exception& e) {
12057       {
12058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (Dali::DaliException e) {
12061       {
12062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12063       };
12064     } catch (...) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12067       };
12068     }
12069   }
12070
12071   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12077   void * jresult ;
12078   Dali::Quaternion *arg1 = 0 ;
12079   Dali::Quaternion *arg2 = 0 ;
12080   Dali::Quaternion *arg3 = 0 ;
12081   Dali::Quaternion *arg4 = 0 ;
12082   float arg5 ;
12083   Dali::Quaternion result;
12084
12085   arg1 = (Dali::Quaternion *)jarg1;
12086   if (!arg1) {
12087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12088     return 0;
12089   }
12090   arg2 = (Dali::Quaternion *)jarg2;
12091   if (!arg2) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12093     return 0;
12094   }
12095   arg3 = (Dali::Quaternion *)jarg3;
12096   if (!arg3) {
12097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12098     return 0;
12099   }
12100   arg4 = (Dali::Quaternion *)jarg4;
12101   if (!arg4) {
12102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12103     return 0;
12104   }
12105   arg5 = (float)jarg5;
12106   {
12107     try {
12108       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12109     } catch (std::out_of_range& e) {
12110       {
12111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12112       };
12113     } catch (std::exception& e) {
12114       {
12115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (Dali::DaliException e) {
12118       {
12119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127
12128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12134   float jresult ;
12135   Dali::Quaternion *arg1 = 0 ;
12136   Dali::Quaternion *arg2 = 0 ;
12137   float result;
12138
12139   arg1 = (Dali::Quaternion *)jarg1;
12140   if (!arg1) {
12141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12142     return 0;
12143   }
12144   arg2 = (Dali::Quaternion *)jarg2;
12145   if (!arg2) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12147     return 0;
12148   }
12149   {
12150     try {
12151       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12152     } catch (std::out_of_range& e) {
12153       {
12154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (std::exception& e) {
12157       {
12158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (Dali::DaliException e) {
12161       {
12162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12163       };
12164     } catch (...) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12167       };
12168     }
12169   }
12170
12171   jresult = result;
12172   return jresult;
12173 }
12174
12175
12176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12177   void * jresult ;
12178   Dali::Matrix *result = 0 ;
12179
12180   {
12181     try {
12182       result = (Dali::Matrix *)new Dali::Matrix();
12183     } catch (std::out_of_range& e) {
12184       {
12185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12186       };
12187     } catch (std::exception& e) {
12188       {
12189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (Dali::DaliException e) {
12192       {
12193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12194       };
12195     } catch (...) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12198       };
12199     }
12200   }
12201
12202   jresult = (void *)result;
12203   return jresult;
12204 }
12205
12206
12207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12208   void * jresult ;
12209   bool arg1 ;
12210   Dali::Matrix *result = 0 ;
12211
12212   arg1 = jarg1 ? true : false;
12213   {
12214     try {
12215       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12216     } catch (std::out_of_range& e) {
12217       {
12218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12219       };
12220     } catch (std::exception& e) {
12221       {
12222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (Dali::DaliException e) {
12225       {
12226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12227       };
12228     } catch (...) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12231       };
12232     }
12233   }
12234
12235   jresult = (void *)result;
12236   return jresult;
12237 }
12238
12239
12240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12241   void * jresult ;
12242   float *arg1 = (float *) 0 ;
12243   Dali::Matrix *result = 0 ;
12244
12245   arg1 = jarg1;
12246   {
12247     try {
12248       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12249     } catch (std::out_of_range& e) {
12250       {
12251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12252       };
12253     } catch (std::exception& e) {
12254       {
12255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (Dali::DaliException e) {
12258       {
12259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12260       };
12261     } catch (...) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12264       };
12265     }
12266   }
12267
12268   jresult = (void *)result;
12269
12270
12271   return jresult;
12272 }
12273
12274
12275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12276   void * jresult ;
12277   Dali::Quaternion *arg1 = 0 ;
12278   Dali::Matrix *result = 0 ;
12279
12280   arg1 = (Dali::Quaternion *)jarg1;
12281   if (!arg1) {
12282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12283     return 0;
12284   }
12285   {
12286     try {
12287       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12288     } catch (std::out_of_range& e) {
12289       {
12290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12291       };
12292     } catch (std::exception& e) {
12293       {
12294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (Dali::DaliException e) {
12297       {
12298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12303       };
12304     }
12305   }
12306
12307   jresult = (void *)result;
12308   return jresult;
12309 }
12310
12311
12312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12313   void * jresult ;
12314   Dali::Matrix *arg1 = 0 ;
12315   Dali::Matrix *result = 0 ;
12316
12317   arg1 = (Dali::Matrix *)jarg1;
12318   if (!arg1) {
12319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12320     return 0;
12321   }
12322   {
12323     try {
12324       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12325     } catch (std::out_of_range& e) {
12326       {
12327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (std::exception& e) {
12330       {
12331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (Dali::DaliException e) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12336       };
12337     } catch (...) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12340       };
12341     }
12342   }
12343
12344   jresult = (void *)result;
12345   return jresult;
12346 }
12347
12348
12349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12350   void * jresult ;
12351   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12352   Dali::Matrix *arg2 = 0 ;
12353   Dali::Matrix *result = 0 ;
12354
12355   arg1 = (Dali::Matrix *)jarg1;
12356   arg2 = (Dali::Matrix *)jarg2;
12357   if (!arg2) {
12358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12359     return 0;
12360   }
12361   {
12362     try {
12363       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12364     } catch (std::out_of_range& e) {
12365       {
12366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12367       };
12368     } catch (std::exception& e) {
12369       {
12370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (Dali::DaliException e) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12375       };
12376     } catch (...) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12379       };
12380     }
12381   }
12382
12383   jresult = (void *)result;
12384   return jresult;
12385 }
12386
12387
12388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12389   void * jresult ;
12390   Dali::Matrix *result = 0 ;
12391
12392   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12393   jresult = (void *)result;
12394   return jresult;
12395 }
12396
12397
12398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12399   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12400
12401   arg1 = (Dali::Matrix *)jarg1;
12402   {
12403     try {
12404       (arg1)->SetIdentity();
12405     } catch (std::out_of_range& e) {
12406       {
12407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12408       };
12409     } catch (std::exception& e) {
12410       {
12411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (Dali::DaliException e) {
12414       {
12415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12416       };
12417     } catch (...) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12420       };
12421     }
12422   }
12423
12424 }
12425
12426
12427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12428   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12429   Dali::Vector3 *arg2 = 0 ;
12430
12431   arg1 = (Dali::Matrix *)jarg1;
12432   arg2 = (Dali::Vector3 *)jarg2;
12433   if (!arg2) {
12434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12435     return ;
12436   }
12437   {
12438     try {
12439       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12440     } catch (std::out_of_range& e) {
12441       {
12442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12443       };
12444     } catch (std::exception& e) {
12445       {
12446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (Dali::DaliException e) {
12449       {
12450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12451       };
12452     } catch (...) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12455       };
12456     }
12457   }
12458
12459 }
12460
12461
12462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12463   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12464   Dali::Matrix *arg2 = 0 ;
12465
12466   arg1 = (Dali::Matrix *)jarg1;
12467   arg2 = (Dali::Matrix *)jarg2;
12468   if (!arg2) {
12469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12470     return ;
12471   }
12472   {
12473     try {
12474       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12475     } catch (std::out_of_range& e) {
12476       {
12477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12478       };
12479     } catch (std::exception& e) {
12480       {
12481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (Dali::DaliException e) {
12484       {
12485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12486       };
12487     } catch (...) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12490       };
12491     }
12492   }
12493
12494 }
12495
12496
12497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12498   unsigned int jresult ;
12499   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12500   bool result;
12501
12502   arg1 = (Dali::Matrix *)jarg1;
12503   {
12504     try {
12505       result = (bool)(arg1)->Invert();
12506     } catch (std::out_of_range& e) {
12507       {
12508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12509       };
12510     } catch (std::exception& e) {
12511       {
12512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (Dali::DaliException e) {
12515       {
12516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12517       };
12518     } catch (...) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12521       };
12522     }
12523   }
12524
12525   jresult = result;
12526   return jresult;
12527 }
12528
12529
12530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12531   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12532
12533   arg1 = (Dali::Matrix *)jarg1;
12534   {
12535     try {
12536       (arg1)->Transpose();
12537     } catch (std::out_of_range& e) {
12538       {
12539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12540       };
12541     } catch (std::exception& e) {
12542       {
12543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (Dali::DaliException e) {
12546       {
12547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12548       };
12549     } catch (...) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12552       };
12553     }
12554   }
12555
12556 }
12557
12558
12559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12560   void * jresult ;
12561   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12562   Dali::Vector3 result;
12563
12564   arg1 = (Dali::Matrix *)jarg1;
12565   {
12566     try {
12567       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12568     } catch (std::out_of_range& e) {
12569       {
12570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12571       };
12572     } catch (std::exception& e) {
12573       {
12574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (Dali::DaliException e) {
12577       {
12578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12579       };
12580     } catch (...) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12583       };
12584     }
12585   }
12586
12587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12588   return jresult;
12589 }
12590
12591
12592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12593   void * jresult ;
12594   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12595   Dali::Vector3 result;
12596
12597   arg1 = (Dali::Matrix *)jarg1;
12598   {
12599     try {
12600       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12601     } catch (std::out_of_range& e) {
12602       {
12603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12604       };
12605     } catch (std::exception& e) {
12606       {
12607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (Dali::DaliException e) {
12610       {
12611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12612       };
12613     } catch (...) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12616       };
12617     }
12618   }
12619
12620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12621   return jresult;
12622 }
12623
12624
12625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12626   void * jresult ;
12627   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12628   Dali::Vector3 result;
12629
12630   arg1 = (Dali::Matrix *)jarg1;
12631   {
12632     try {
12633       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12634     } catch (std::out_of_range& e) {
12635       {
12636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12637       };
12638     } catch (std::exception& e) {
12639       {
12640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (Dali::DaliException e) {
12643       {
12644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12645       };
12646     } catch (...) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12649       };
12650     }
12651   }
12652
12653   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12654   return jresult;
12655 }
12656
12657
12658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12659   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12660   Dali::Vector3 *arg2 = 0 ;
12661
12662   arg1 = (Dali::Matrix *)jarg1;
12663   arg2 = (Dali::Vector3 *)jarg2;
12664   if (!arg2) {
12665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12666     return ;
12667   }
12668   {
12669     try {
12670       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12671     } catch (std::out_of_range& e) {
12672       {
12673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12674       };
12675     } catch (std::exception& e) {
12676       {
12677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (Dali::DaliException e) {
12680       {
12681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12682       };
12683     } catch (...) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12686       };
12687     }
12688   }
12689
12690 }
12691
12692
12693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12694   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12695   Dali::Vector3 *arg2 = 0 ;
12696
12697   arg1 = (Dali::Matrix *)jarg1;
12698   arg2 = (Dali::Vector3 *)jarg2;
12699   if (!arg2) {
12700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12701     return ;
12702   }
12703   {
12704     try {
12705       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12706     } catch (std::out_of_range& e) {
12707       {
12708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12709       };
12710     } catch (std::exception& e) {
12711       {
12712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (Dali::DaliException e) {
12715       {
12716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12717       };
12718     } catch (...) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12721       };
12722     }
12723   }
12724
12725 }
12726
12727
12728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12729   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12730   Dali::Vector3 *arg2 = 0 ;
12731
12732   arg1 = (Dali::Matrix *)jarg1;
12733   arg2 = (Dali::Vector3 *)jarg2;
12734   if (!arg2) {
12735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12736     return ;
12737   }
12738   {
12739     try {
12740       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12741     } catch (std::out_of_range& e) {
12742       {
12743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12744       };
12745     } catch (std::exception& e) {
12746       {
12747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (Dali::DaliException e) {
12750       {
12751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12752       };
12753     } catch (...) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12756       };
12757     }
12758   }
12759
12760 }
12761
12762
12763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12764   void * jresult ;
12765   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12766   Dali::Vector4 *result = 0 ;
12767
12768   arg1 = (Dali::Matrix *)jarg1;
12769   {
12770     try {
12771       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12772     } catch (std::out_of_range& e) {
12773       {
12774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12775       };
12776     } catch (std::exception& e) {
12777       {
12778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (Dali::DaliException e) {
12781       {
12782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12783       };
12784     } catch (...) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12787       };
12788     }
12789   }
12790
12791   jresult = (void *)result;
12792   return jresult;
12793 }
12794
12795
12796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12797   void * jresult ;
12798   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12799   Dali::Vector3 *result = 0 ;
12800
12801   arg1 = (Dali::Matrix *)jarg1;
12802   {
12803     try {
12804       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12805     } catch (std::out_of_range& e) {
12806       {
12807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12808       };
12809     } catch (std::exception& e) {
12810       {
12811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (Dali::DaliException e) {
12814       {
12815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12816       };
12817     } catch (...) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12820       };
12821     }
12822   }
12823
12824   jresult = (void *)result;
12825   return jresult;
12826 }
12827
12828
12829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12830   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12831   Dali::Vector4 *arg2 = 0 ;
12832
12833   arg1 = (Dali::Matrix *)jarg1;
12834   arg2 = (Dali::Vector4 *)jarg2;
12835   if (!arg2) {
12836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12837     return ;
12838   }
12839   {
12840     try {
12841       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12842     } catch (std::out_of_range& e) {
12843       {
12844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12845       };
12846     } catch (std::exception& e) {
12847       {
12848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (Dali::DaliException e) {
12851       {
12852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12853       };
12854     } catch (...) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12857       };
12858     }
12859   }
12860
12861 }
12862
12863
12864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12865   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12866   Dali::Vector3 *arg2 = 0 ;
12867
12868   arg1 = (Dali::Matrix *)jarg1;
12869   arg2 = (Dali::Vector3 *)jarg2;
12870   if (!arg2) {
12871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12872     return ;
12873   }
12874   {
12875     try {
12876       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12877     } catch (std::out_of_range& e) {
12878       {
12879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12880       };
12881     } catch (std::exception& e) {
12882       {
12883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (Dali::DaliException e) {
12886       {
12887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12888       };
12889     } catch (...) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12892       };
12893     }
12894   }
12895
12896 }
12897
12898
12899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12900   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12901
12902   arg1 = (Dali::Matrix *)jarg1;
12903   {
12904     try {
12905       (arg1)->OrthoNormalize();
12906     } catch (std::out_of_range& e) {
12907       {
12908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12909       };
12910     } catch (std::exception& e) {
12911       {
12912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (Dali::DaliException e) {
12915       {
12916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12917       };
12918     } catch (...) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12921       };
12922     }
12923   }
12924
12925 }
12926
12927
12928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12929   void * jresult ;
12930   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12931   float *result = 0 ;
12932
12933   arg1 = (Dali::Matrix *)jarg1;
12934   {
12935     try {
12936       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12937     } catch (std::out_of_range& e) {
12938       {
12939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12940       };
12941     } catch (std::exception& e) {
12942       {
12943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (Dali::DaliException e) {
12946       {
12947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12948       };
12949     } catch (...) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12952       };
12953     }
12954   }
12955
12956   jresult = (void *)result;
12957   return jresult;
12958 }
12959
12960
12961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12962   Dali::Matrix *arg1 = 0 ;
12963   Dali::Matrix *arg2 = 0 ;
12964   Dali::Matrix *arg3 = 0 ;
12965
12966   arg1 = (Dali::Matrix *)jarg1;
12967   if (!arg1) {
12968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12969     return ;
12970   }
12971   arg2 = (Dali::Matrix *)jarg2;
12972   if (!arg2) {
12973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12974     return ;
12975   }
12976   arg3 = (Dali::Matrix *)jarg3;
12977   if (!arg3) {
12978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12979     return ;
12980   }
12981   {
12982     try {
12983       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12984     } catch (std::out_of_range& e) {
12985       {
12986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12987       };
12988     } catch (std::exception& e) {
12989       {
12990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (Dali::DaliException e) {
12993       {
12994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12995       };
12996     } catch (...) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12999       };
13000     }
13001   }
13002
13003 }
13004
13005
13006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13007   Dali::Matrix *arg1 = 0 ;
13008   Dali::Matrix *arg2 = 0 ;
13009   Dali::Quaternion *arg3 = 0 ;
13010
13011   arg1 = (Dali::Matrix *)jarg1;
13012   if (!arg1) {
13013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13014     return ;
13015   }
13016   arg2 = (Dali::Matrix *)jarg2;
13017   if (!arg2) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13019     return ;
13020   }
13021   arg3 = (Dali::Quaternion *)jarg3;
13022   if (!arg3) {
13023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13024     return ;
13025   }
13026   {
13027     try {
13028       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13029     } catch (std::out_of_range& e) {
13030       {
13031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13032       };
13033     } catch (std::exception& e) {
13034       {
13035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (Dali::DaliException e) {
13038       {
13039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13040       };
13041     } catch (...) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13044       };
13045     }
13046   }
13047
13048 }
13049
13050
13051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13052   void * jresult ;
13053   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13054   Dali::Vector4 *arg2 = 0 ;
13055   Dali::Vector4 result;
13056
13057   arg1 = (Dali::Matrix *)jarg1;
13058   arg2 = (Dali::Vector4 *)jarg2;
13059   if (!arg2) {
13060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13061     return 0;
13062   }
13063   {
13064     try {
13065       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13066     } catch (std::out_of_range& e) {
13067       {
13068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13069       };
13070     } catch (std::exception& e) {
13071       {
13072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (Dali::DaliException e) {
13075       {
13076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084
13085   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13086   return jresult;
13087 }
13088
13089
13090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13091   unsigned int jresult ;
13092   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13093   Dali::Matrix *arg2 = 0 ;
13094   bool result;
13095
13096   arg1 = (Dali::Matrix *)jarg1;
13097   arg2 = (Dali::Matrix *)jarg2;
13098   if (!arg2) {
13099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13100     return 0;
13101   }
13102   {
13103     try {
13104       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13105     } catch (std::out_of_range& e) {
13106       {
13107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13108       };
13109     } catch (std::exception& e) {
13110       {
13111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (Dali::DaliException e) {
13114       {
13115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13116       };
13117     } catch (...) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13120       };
13121     }
13122   }
13123
13124   jresult = result;
13125   return jresult;
13126 }
13127
13128
13129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13130   unsigned int jresult ;
13131   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13132   Dali::Matrix *arg2 = 0 ;
13133   bool result;
13134
13135   arg1 = (Dali::Matrix *)jarg1;
13136   arg2 = (Dali::Matrix *)jarg2;
13137   if (!arg2) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13139     return 0;
13140   }
13141   {
13142     try {
13143       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13144     } catch (std::out_of_range& e) {
13145       {
13146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13147       };
13148     } catch (std::exception& e) {
13149       {
13150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (Dali::DaliException e) {
13153       {
13154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13155       };
13156     } catch (...) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13159       };
13160     }
13161   }
13162
13163   jresult = result;
13164   return jresult;
13165 }
13166
13167
13168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13169   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13170   Dali::Vector3 *arg2 = 0 ;
13171   Dali::Quaternion *arg3 = 0 ;
13172   Dali::Vector3 *arg4 = 0 ;
13173
13174   arg1 = (Dali::Matrix *)jarg1;
13175   arg2 = (Dali::Vector3 *)jarg2;
13176   if (!arg2) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13178     return ;
13179   }
13180   arg3 = (Dali::Quaternion *)jarg3;
13181   if (!arg3) {
13182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13183     return ;
13184   }
13185   arg4 = (Dali::Vector3 *)jarg4;
13186   if (!arg4) {
13187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13188     return ;
13189   }
13190   {
13191     try {
13192       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13193     } catch (std::out_of_range& e) {
13194       {
13195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13196       };
13197     } catch (std::exception& e) {
13198       {
13199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (Dali::DaliException e) {
13202       {
13203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13204       };
13205     } catch (...) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13208       };
13209     }
13210   }
13211
13212 }
13213
13214
13215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13216   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13217   Dali::Vector3 *arg2 = 0 ;
13218   Dali::Quaternion *arg3 = 0 ;
13219   Dali::Vector3 *arg4 = 0 ;
13220
13221   arg1 = (Dali::Matrix *)jarg1;
13222   arg2 = (Dali::Vector3 *)jarg2;
13223   if (!arg2) {
13224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13225     return ;
13226   }
13227   arg3 = (Dali::Quaternion *)jarg3;
13228   if (!arg3) {
13229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13230     return ;
13231   }
13232   arg4 = (Dali::Vector3 *)jarg4;
13233   if (!arg4) {
13234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13235     return ;
13236   }
13237   {
13238     try {
13239       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13240     } catch (std::out_of_range& e) {
13241       {
13242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13243       };
13244     } catch (std::exception& e) {
13245       {
13246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (Dali::DaliException e) {
13249       {
13250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13251       };
13252     } catch (...) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13255       };
13256     }
13257   }
13258
13259 }
13260
13261
13262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13264   Dali::Vector3 *arg2 = 0 ;
13265   Dali::Vector3 *arg3 = 0 ;
13266   Dali::Vector3 *arg4 = 0 ;
13267   Dali::Vector3 *arg5 = 0 ;
13268
13269   arg1 = (Dali::Matrix *)jarg1;
13270   arg2 = (Dali::Vector3 *)jarg2;
13271   if (!arg2) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13273     return ;
13274   }
13275   arg3 = (Dali::Vector3 *)jarg3;
13276   if (!arg3) {
13277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13278     return ;
13279   }
13280   arg4 = (Dali::Vector3 *)jarg4;
13281   if (!arg4) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13283     return ;
13284   }
13285   arg5 = (Dali::Vector3 *)jarg5;
13286   if (!arg5) {
13287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13288     return ;
13289   }
13290   {
13291     try {
13292       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13293     } catch (std::out_of_range& e) {
13294       {
13295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13296       };
13297     } catch (std::exception& e) {
13298       {
13299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (Dali::DaliException e) {
13302       {
13303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13304       };
13305     } catch (...) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13308       };
13309     }
13310   }
13311
13312 }
13313
13314
13315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13316   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13317   Dali::Vector3 *arg2 = 0 ;
13318   Dali::Quaternion *arg3 = 0 ;
13319   Dali::Vector3 *arg4 = 0 ;
13320
13321   arg1 = (Dali::Matrix *)jarg1;
13322   arg2 = (Dali::Vector3 *)jarg2;
13323   if (!arg2) {
13324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13325     return ;
13326   }
13327   arg3 = (Dali::Quaternion *)jarg3;
13328   if (!arg3) {
13329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13330     return ;
13331   }
13332   arg4 = (Dali::Vector3 *)jarg4;
13333   if (!arg4) {
13334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13335     return ;
13336   }
13337   {
13338     try {
13339       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13340     } catch (std::out_of_range& e) {
13341       {
13342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13343       };
13344     } catch (std::exception& e) {
13345       {
13346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (Dali::DaliException e) {
13349       {
13350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13351       };
13352     } catch (...) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13355       };
13356     }
13357   }
13358
13359 }
13360
13361
13362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13363   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13364
13365   arg1 = (Dali::Matrix *)jarg1;
13366   {
13367     try {
13368       delete arg1;
13369     } catch (std::out_of_range& e) {
13370       {
13371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13372       };
13373     } catch (std::exception& e) {
13374       {
13375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (Dali::DaliException e) {
13378       {
13379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13380       };
13381     } catch (...) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13384       };
13385     }
13386   }
13387
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13392   void * jresult ;
13393   Dali::Matrix3 *result = 0 ;
13394
13395   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13396   jresult = (void *)result;
13397   return jresult;
13398 }
13399
13400
13401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13402   void * jresult ;
13403   Dali::Matrix3 *result = 0 ;
13404
13405   {
13406     try {
13407       result = (Dali::Matrix3 *)new Dali::Matrix3();
13408     } catch (std::out_of_range& e) {
13409       {
13410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13411       };
13412     } catch (std::exception& e) {
13413       {
13414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (Dali::DaliException e) {
13417       {
13418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13419       };
13420     } catch (...) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13423       };
13424     }
13425   }
13426
13427   jresult = (void *)result;
13428   return jresult;
13429 }
13430
13431
13432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13433   void * jresult ;
13434   Dali::Matrix3 *arg1 = 0 ;
13435   Dali::Matrix3 *result = 0 ;
13436
13437   arg1 = (Dali::Matrix3 *)jarg1;
13438   if (!arg1) {
13439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13440     return 0;
13441   }
13442   {
13443     try {
13444       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13445     } catch (std::out_of_range& e) {
13446       {
13447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13448       };
13449     } catch (std::exception& e) {
13450       {
13451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (Dali::DaliException e) {
13454       {
13455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13456       };
13457     } catch (...) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13460       };
13461     }
13462   }
13463
13464   jresult = (void *)result;
13465   return jresult;
13466 }
13467
13468
13469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13470   void * jresult ;
13471   Dali::Matrix *arg1 = 0 ;
13472   Dali::Matrix3 *result = 0 ;
13473
13474   arg1 = (Dali::Matrix *)jarg1;
13475   if (!arg1) {
13476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13477     return 0;
13478   }
13479   {
13480     try {
13481       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13482     } catch (std::out_of_range& e) {
13483       {
13484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13485       };
13486     } catch (std::exception& e) {
13487       {
13488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (Dali::DaliException e) {
13491       {
13492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13493       };
13494     } catch (...) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13497       };
13498     }
13499   }
13500
13501   jresult = (void *)result;
13502   return jresult;
13503 }
13504
13505
13506 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) {
13507   void * jresult ;
13508   float arg1 ;
13509   float arg2 ;
13510   float arg3 ;
13511   float arg4 ;
13512   float arg5 ;
13513   float arg6 ;
13514   float arg7 ;
13515   float arg8 ;
13516   float arg9 ;
13517   Dali::Matrix3 *result = 0 ;
13518
13519   arg1 = (float)jarg1;
13520   arg2 = (float)jarg2;
13521   arg3 = (float)jarg3;
13522   arg4 = (float)jarg4;
13523   arg5 = (float)jarg5;
13524   arg6 = (float)jarg6;
13525   arg7 = (float)jarg7;
13526   arg8 = (float)jarg8;
13527   arg9 = (float)jarg9;
13528   {
13529     try {
13530       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13531     } catch (std::out_of_range& e) {
13532       {
13533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (std::exception& e) {
13536       {
13537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (Dali::DaliException e) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13542       };
13543     } catch (...) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13546       };
13547     }
13548   }
13549
13550   jresult = (void *)result;
13551   return jresult;
13552 }
13553
13554
13555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13556   void * jresult ;
13557   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13558   Dali::Matrix3 *arg2 = 0 ;
13559   Dali::Matrix3 *result = 0 ;
13560
13561   arg1 = (Dali::Matrix3 *)jarg1;
13562   arg2 = (Dali::Matrix3 *)jarg2;
13563   if (!arg2) {
13564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13565     return 0;
13566   }
13567   {
13568     try {
13569       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13570     } catch (std::out_of_range& e) {
13571       {
13572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13573       };
13574     } catch (std::exception& e) {
13575       {
13576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (Dali::DaliException e) {
13579       {
13580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13581       };
13582     } catch (...) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13585       };
13586     }
13587   }
13588
13589   jresult = (void *)result;
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13595   void * jresult ;
13596   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13597   Dali::Matrix *arg2 = 0 ;
13598   Dali::Matrix3 *result = 0 ;
13599
13600   arg1 = (Dali::Matrix3 *)jarg1;
13601   arg2 = (Dali::Matrix *)jarg2;
13602   if (!arg2) {
13603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13604     return 0;
13605   }
13606   {
13607     try {
13608       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13609     } catch (std::out_of_range& e) {
13610       {
13611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13612       };
13613     } catch (std::exception& e) {
13614       {
13615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (Dali::DaliException e) {
13618       {
13619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13620       };
13621     } catch (...) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13624       };
13625     }
13626   }
13627
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13634   unsigned int jresult ;
13635   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13636   Dali::Matrix3 *arg2 = 0 ;
13637   bool result;
13638
13639   arg1 = (Dali::Matrix3 *)jarg1;
13640   arg2 = (Dali::Matrix3 *)jarg2;
13641   if (!arg2) {
13642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13643     return 0;
13644   }
13645   {
13646     try {
13647       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13648     } catch (std::out_of_range& e) {
13649       {
13650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (std::exception& e) {
13653       {
13654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (Dali::DaliException e) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13659       };
13660     } catch (...) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13663       };
13664     }
13665   }
13666
13667   jresult = result;
13668   return jresult;
13669 }
13670
13671
13672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13673   unsigned int jresult ;
13674   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13675   Dali::Matrix3 *arg2 = 0 ;
13676   bool result;
13677
13678   arg1 = (Dali::Matrix3 *)jarg1;
13679   arg2 = (Dali::Matrix3 *)jarg2;
13680   if (!arg2) {
13681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13682     return 0;
13683   }
13684   {
13685     try {
13686       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13687     } catch (std::out_of_range& e) {
13688       {
13689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13690       };
13691     } catch (std::exception& e) {
13692       {
13693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (Dali::DaliException e) {
13696       {
13697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13698       };
13699     } catch (...) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13702       };
13703     }
13704   }
13705
13706   jresult = result;
13707   return jresult;
13708 }
13709
13710
13711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13712   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13713
13714   arg1 = (Dali::Matrix3 *)jarg1;
13715   {
13716     try {
13717       delete arg1;
13718     } catch (std::out_of_range& e) {
13719       {
13720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13721       };
13722     } catch (std::exception& e) {
13723       {
13724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (Dali::DaliException e) {
13727       {
13728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13729       };
13730     } catch (...) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13733       };
13734     }
13735   }
13736
13737 }
13738
13739
13740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13741   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13742
13743   arg1 = (Dali::Matrix3 *)jarg1;
13744   {
13745     try {
13746       (arg1)->SetIdentity();
13747     } catch (std::out_of_range& e) {
13748       {
13749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13750       };
13751     } catch (std::exception& e) {
13752       {
13753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (Dali::DaliException e) {
13756       {
13757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13758       };
13759     } catch (...) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13762       };
13763     }
13764   }
13765
13766 }
13767
13768
13769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13770   void * jresult ;
13771   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13772   float *result = 0 ;
13773
13774   arg1 = (Dali::Matrix3 *)jarg1;
13775   {
13776     try {
13777       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13778     } catch (std::out_of_range& e) {
13779       {
13780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13781       };
13782     } catch (std::exception& e) {
13783       {
13784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (Dali::DaliException e) {
13787       {
13788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13789       };
13790     } catch (...) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13793       };
13794     }
13795   }
13796
13797   jresult = (void *)result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13803   unsigned int jresult ;
13804   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13805   bool result;
13806
13807   arg1 = (Dali::Matrix3 *)jarg1;
13808   {
13809     try {
13810       result = (bool)(arg1)->Invert();
13811     } catch (std::out_of_range& e) {
13812       {
13813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13814       };
13815     } catch (std::exception& e) {
13816       {
13817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (Dali::DaliException e) {
13820       {
13821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13822       };
13823     } catch (...) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13826       };
13827     }
13828   }
13829
13830   jresult = result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13836   unsigned int jresult ;
13837   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13838   bool result;
13839
13840   arg1 = (Dali::Matrix3 *)jarg1;
13841   {
13842     try {
13843       result = (bool)(arg1)->Transpose();
13844     } catch (std::out_of_range& e) {
13845       {
13846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13847       };
13848     } catch (std::exception& e) {
13849       {
13850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (Dali::DaliException e) {
13853       {
13854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13855       };
13856     } catch (...) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13859       };
13860     }
13861   }
13862
13863   jresult = result;
13864   return jresult;
13865 }
13866
13867
13868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13869   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13870   float arg2 ;
13871
13872   arg1 = (Dali::Matrix3 *)jarg1;
13873   arg2 = (float)jarg2;
13874   {
13875     try {
13876       (arg1)->Scale(arg2);
13877     } catch (std::out_of_range& e) {
13878       {
13879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13880       };
13881     } catch (std::exception& e) {
13882       {
13883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (Dali::DaliException e) {
13886       {
13887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13888       };
13889     } catch (...) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13892       };
13893     }
13894   }
13895
13896 }
13897
13898
13899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13900   float jresult ;
13901   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13902   float result;
13903
13904   arg1 = (Dali::Matrix3 *)jarg1;
13905   {
13906     try {
13907       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13908     } catch (std::out_of_range& e) {
13909       {
13910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13911       };
13912     } catch (std::exception& e) {
13913       {
13914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (Dali::DaliException e) {
13917       {
13918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13919       };
13920     } catch (...) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13923       };
13924     }
13925   }
13926
13927   jresult = result;
13928   return jresult;
13929 }
13930
13931
13932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13933   unsigned int jresult ;
13934   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13935   bool result;
13936
13937   arg1 = (Dali::Matrix3 *)jarg1;
13938   {
13939     try {
13940       result = (bool)(arg1)->ScaledInverseTranspose();
13941     } catch (std::out_of_range& e) {
13942       {
13943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13944       };
13945     } catch (std::exception& e) {
13946       {
13947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (Dali::DaliException e) {
13950       {
13951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13952       };
13953     } catch (...) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13956       };
13957     }
13958   }
13959
13960   jresult = result;
13961   return jresult;
13962 }
13963
13964
13965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13966   Dali::Matrix3 *arg1 = 0 ;
13967   Dali::Matrix3 *arg2 = 0 ;
13968   Dali::Matrix3 *arg3 = 0 ;
13969
13970   arg1 = (Dali::Matrix3 *)jarg1;
13971   if (!arg1) {
13972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13973     return ;
13974   }
13975   arg2 = (Dali::Matrix3 *)jarg2;
13976   if (!arg2) {
13977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13978     return ;
13979   }
13980   arg3 = (Dali::Matrix3 *)jarg3;
13981   if (!arg3) {
13982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13983     return ;
13984   }
13985   {
13986     try {
13987       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13988     } catch (std::out_of_range& e) {
13989       {
13990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13991       };
13992     } catch (std::exception& e) {
13993       {
13994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (Dali::DaliException e) {
13997       {
13998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13999       };
14000     } catch (...) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14003       };
14004     }
14005   }
14006
14007 }
14008
14009
14010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14011   float jresult ;
14012   float arg1 ;
14013   float arg2 ;
14014   float result;
14015
14016   arg1 = (float)jarg1;
14017   arg2 = (float)jarg2;
14018   {
14019     try {
14020       result = (float)Dali::Random::Range(arg1,arg2);
14021     } catch (std::out_of_range& e) {
14022       {
14023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14024       };
14025     } catch (std::exception& e) {
14026       {
14027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (Dali::DaliException e) {
14030       {
14031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14032       };
14033     } catch (...) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14036       };
14037     }
14038   }
14039
14040   jresult = result;
14041   return jresult;
14042 }
14043
14044
14045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14046   void * jresult ;
14047   Dali::Vector4 result;
14048
14049   {
14050     try {
14051       result = Dali::Random::Axis();
14052     } catch (std::out_of_range& e) {
14053       {
14054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14055       };
14056     } catch (std::exception& e) {
14057       {
14058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (Dali::DaliException e) {
14061       {
14062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14063       };
14064     } catch (...) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14067       };
14068     }
14069   }
14070
14071   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14072   return jresult;
14073 }
14074
14075
14076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14077   void * jresult ;
14078   Dali::AngleAxis *result = 0 ;
14079
14080   {
14081     try {
14082       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14083     } catch (std::out_of_range& e) {
14084       {
14085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14086       };
14087     } catch (std::exception& e) {
14088       {
14089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (Dali::DaliException e) {
14092       {
14093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14094       };
14095     } catch (...) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14098       };
14099     }
14100   }
14101
14102   jresult = (void *)result;
14103   return jresult;
14104 }
14105
14106
14107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14108   void * jresult ;
14109   Dali::Radian arg1 ;
14110   Dali::Vector3 *arg2 = 0 ;
14111   Dali::Radian *argp1 ;
14112   Dali::AngleAxis *result = 0 ;
14113
14114   argp1 = (Dali::Radian *)jarg1;
14115   if (!argp1) {
14116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14117     return 0;
14118   }
14119   arg1 = *argp1;
14120   arg2 = (Dali::Vector3 *)jarg2;
14121   if (!arg2) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14123     return 0;
14124   }
14125   {
14126     try {
14127       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14128     } catch (std::out_of_range& e) {
14129       {
14130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14131       };
14132     } catch (std::exception& e) {
14133       {
14134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (Dali::DaliException e) {
14137       {
14138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14139       };
14140     } catch (...) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14143       };
14144     }
14145   }
14146
14147   jresult = (void *)result;
14148   return jresult;
14149 }
14150
14151
14152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14153   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14154   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14155
14156   arg1 = (Dali::AngleAxis *)jarg1;
14157   arg2 = (Dali::Radian *)jarg2;
14158   if (arg1) (arg1)->angle = *arg2;
14159 }
14160
14161
14162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14163   void * jresult ;
14164   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14165   Dali::Radian *result = 0 ;
14166
14167   arg1 = (Dali::AngleAxis *)jarg1;
14168   result = (Dali::Radian *)& ((arg1)->angle);
14169   jresult = (void *)result;
14170   return jresult;
14171 }
14172
14173
14174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14175   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14176   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14177
14178   arg1 = (Dali::AngleAxis *)jarg1;
14179   arg2 = (Dali::Vector3 *)jarg2;
14180   if (arg1) (arg1)->axis = *arg2;
14181 }
14182
14183
14184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14185   void * jresult ;
14186   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14187   Dali::Vector3 *result = 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   result = (Dali::Vector3 *)& ((arg1)->axis);
14191   jresult = (void *)result;
14192   return jresult;
14193 }
14194
14195
14196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14197   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14198
14199   arg1 = (Dali::AngleAxis *)jarg1;
14200   {
14201     try {
14202       delete arg1;
14203     } catch (std::out_of_range& e) {
14204       {
14205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14206       };
14207     } catch (std::exception& e) {
14208       {
14209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (Dali::DaliException e) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14214       };
14215     } catch (...) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14218       };
14219     }
14220   }
14221
14222 }
14223
14224
14225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14226   unsigned int jresult ;
14227   Dali::AngleAxis *arg1 = 0 ;
14228   Dali::AngleAxis *arg2 = 0 ;
14229   bool result;
14230
14231   arg1 = (Dali::AngleAxis *)jarg1;
14232   if (!arg1) {
14233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14234     return 0;
14235   }
14236   arg2 = (Dali::AngleAxis *)jarg2;
14237   if (!arg2) {
14238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14239     return 0;
14240   }
14241   {
14242     try {
14243       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14244     } catch (std::out_of_range& e) {
14245       {
14246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14247       };
14248     } catch (std::exception& e) {
14249       {
14250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (Dali::DaliException e) {
14253       {
14254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14259       };
14260     }
14261   }
14262
14263   jresult = result;
14264   return jresult;
14265 }
14266
14267
14268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14269   unsigned int jresult ;
14270   unsigned int arg1 ;
14271   unsigned int result;
14272
14273   arg1 = (unsigned int)jarg1;
14274   {
14275     try {
14276       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14277     } catch (std::out_of_range& e) {
14278       {
14279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14280       };
14281     } catch (std::exception& e) {
14282       {
14283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (Dali::DaliException e) {
14286       {
14287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14288       };
14289     } catch (...) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14292       };
14293     }
14294   }
14295
14296   jresult = result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14302   unsigned int jresult ;
14303   unsigned int arg1 ;
14304   bool result;
14305
14306   arg1 = (unsigned int)jarg1;
14307   {
14308     try {
14309       result = (bool)Dali::IsPowerOfTwo(arg1);
14310     } catch (std::out_of_range& e) {
14311       {
14312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14313       };
14314     } catch (std::exception& e) {
14315       {
14316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (Dali::DaliException e) {
14319       {
14320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14321       };
14322     } catch (...) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14325       };
14326     }
14327   }
14328
14329   jresult = result;
14330   return jresult;
14331 }
14332
14333
14334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14335   float jresult ;
14336   float arg1 ;
14337   float arg2 ;
14338   float result;
14339
14340   arg1 = (float)jarg1;
14341   arg2 = (float)jarg2;
14342   {
14343     try {
14344       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14345     } catch (std::out_of_range& e) {
14346       {
14347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14348       };
14349     } catch (std::exception& e) {
14350       {
14351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (Dali::DaliException e) {
14354       {
14355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14356       };
14357     } catch (...) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14360       };
14361     }
14362   }
14363
14364   jresult = result;
14365   return jresult;
14366 }
14367
14368
14369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14370   unsigned int jresult ;
14371   float arg1 ;
14372   bool result;
14373
14374   arg1 = (float)jarg1;
14375   {
14376     try {
14377       result = (bool)Dali::EqualsZero(arg1);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (Dali::DaliException e) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14389       };
14390     } catch (...) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14393       };
14394     }
14395   }
14396
14397   jresult = result;
14398   return jresult;
14399 }
14400
14401
14402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14403   unsigned int jresult ;
14404   float arg1 ;
14405   float arg2 ;
14406   bool result;
14407
14408   arg1 = (float)jarg1;
14409   arg2 = (float)jarg2;
14410   {
14411     try {
14412       result = (bool)Dali::Equals(arg1,arg2);
14413     } catch (std::out_of_range& e) {
14414       {
14415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14416       };
14417     } catch (std::exception& e) {
14418       {
14419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (Dali::DaliException e) {
14422       {
14423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14424       };
14425     } catch (...) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14428       };
14429     }
14430   }
14431
14432   jresult = result;
14433   return jresult;
14434 }
14435
14436
14437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14438   unsigned int jresult ;
14439   float arg1 ;
14440   float arg2 ;
14441   float arg3 ;
14442   bool result;
14443
14444   arg1 = (float)jarg1;
14445   arg2 = (float)jarg2;
14446   arg3 = (float)jarg3;
14447   {
14448     try {
14449       result = (bool)Dali::Equals(arg1,arg2,arg3);
14450     } catch (std::out_of_range& e) {
14451       {
14452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14453       };
14454     } catch (std::exception& e) {
14455       {
14456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (Dali::DaliException e) {
14459       {
14460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14461       };
14462     } catch (...) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14465       };
14466     }
14467   }
14468
14469   jresult = result;
14470   return jresult;
14471 }
14472
14473
14474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14475   float jresult ;
14476   float arg1 ;
14477   int arg2 ;
14478   float result;
14479
14480   arg1 = (float)jarg1;
14481   arg2 = (int)jarg2;
14482   {
14483     try {
14484       result = (float)Dali::Round(arg1,arg2);
14485     } catch (std::out_of_range& e) {
14486       {
14487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14488       };
14489     } catch (std::exception& e) {
14490       {
14491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (Dali::DaliException e) {
14494       {
14495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14496       };
14497     } catch (...) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14500       };
14501     }
14502   }
14503
14504   jresult = result;
14505   return jresult;
14506 }
14507
14508
14509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14510   float jresult ;
14511   float arg1 ;
14512   float arg2 ;
14513   float arg3 ;
14514   float result;
14515
14516   arg1 = (float)jarg1;
14517   arg2 = (float)jarg2;
14518   arg3 = (float)jarg3;
14519   {
14520     try {
14521       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14522     } catch (std::out_of_range& e) {
14523       {
14524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14525       };
14526     } catch (std::exception& e) {
14527       {
14528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (Dali::DaliException e) {
14531       {
14532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14533       };
14534     } catch (...) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14537       };
14538     }
14539   }
14540
14541   jresult = result;
14542   return jresult;
14543 }
14544
14545
14546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14547   float jresult ;
14548   float arg1 ;
14549   float arg2 ;
14550   float arg3 ;
14551   float arg4 ;
14552   float result;
14553
14554   arg1 = (float)jarg1;
14555   arg2 = (float)jarg2;
14556   arg3 = (float)jarg3;
14557   arg4 = (float)jarg4;
14558   {
14559     try {
14560       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14561     } catch (std::out_of_range& e) {
14562       {
14563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14564       };
14565     } catch (std::exception& e) {
14566       {
14567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (Dali::DaliException e) {
14570       {
14571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14572       };
14573     } catch (...) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14576       };
14577     }
14578   }
14579
14580   jresult = result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14586   int jresult ;
14587   int result;
14588
14589   result = (int)(int)Dali::Property::INVALID_INDEX;
14590   jresult = result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14596   int jresult ;
14597   int result;
14598
14599   result = (int)(int)Dali::Property::INVALID_KEY;
14600   jresult = result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14606   int jresult ;
14607   int result;
14608
14609   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14610   jresult = result;
14611   return jresult;
14612 }
14613
14614
14615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14616   void * jresult ;
14617   Dali::Handle *arg1 = 0 ;
14618   Dali::Property::Index arg2 ;
14619   Dali::Property *result = 0 ;
14620
14621   arg1 = (Dali::Handle *)jarg1;
14622   if (!arg1) {
14623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14624     return 0;
14625   }
14626   arg2 = (Dali::Property::Index)jarg2;
14627   {
14628     try {
14629       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (Dali::DaliException e) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14641       };
14642     } catch (...) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14645       };
14646     }
14647   }
14648
14649   jresult = (void *)result;
14650   return jresult;
14651 }
14652
14653
14654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14655   void * jresult ;
14656   Dali::Handle *arg1 = 0 ;
14657   Dali::Property::Index arg2 ;
14658   int arg3 ;
14659   Dali::Property *result = 0 ;
14660
14661   arg1 = (Dali::Handle *)jarg1;
14662   if (!arg1) {
14663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14664     return 0;
14665   }
14666   arg2 = (Dali::Property::Index)jarg2;
14667   arg3 = (int)jarg3;
14668   {
14669     try {
14670       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14671     } catch (std::out_of_range& e) {
14672       {
14673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14674       };
14675     } catch (std::exception& e) {
14676       {
14677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (Dali::DaliException e) {
14680       {
14681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14682       };
14683     } catch (...) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14686       };
14687     }
14688   }
14689
14690   jresult = (void *)result;
14691   return jresult;
14692 }
14693
14694
14695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14696   void * jresult ;
14697   Dali::Handle *arg1 = 0 ;
14698   std::string *arg2 = 0 ;
14699   Dali::Property *result = 0 ;
14700
14701   arg1 = (Dali::Handle *)jarg1;
14702   if (!arg1) {
14703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14704     return 0;
14705   }
14706   if (!jarg2) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14708     return 0;
14709   }
14710   std::string arg2_str(jarg2);
14711   arg2 = &arg2_str;
14712   {
14713     try {
14714       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14715     } catch (std::out_of_range& e) {
14716       {
14717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14718       };
14719     } catch (std::exception& e) {
14720       {
14721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (Dali::DaliException e) {
14724       {
14725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14726       };
14727     } catch (...) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14730       };
14731     }
14732   }
14733
14734   jresult = (void *)result;
14735
14736   //argout typemap for const std::string&
14737
14738   return jresult;
14739 }
14740
14741
14742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14743   void * jresult ;
14744   Dali::Handle *arg1 = 0 ;
14745   std::string *arg2 = 0 ;
14746   int arg3 ;
14747   Dali::Property *result = 0 ;
14748
14749   arg1 = (Dali::Handle *)jarg1;
14750   if (!arg1) {
14751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14752     return 0;
14753   }
14754   if (!jarg2) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14756     return 0;
14757   }
14758   std::string arg2_str(jarg2);
14759   arg2 = &arg2_str;
14760   arg3 = (int)jarg3;
14761   {
14762     try {
14763       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14764     } catch (std::out_of_range& e) {
14765       {
14766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14767       };
14768     } catch (std::exception& e) {
14769       {
14770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (Dali::DaliException e) {
14773       {
14774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14775       };
14776     } catch (...) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14779       };
14780     }
14781   }
14782
14783   jresult = (void *)result;
14784
14785   //argout typemap for const std::string&
14786
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14792   Dali::Property *arg1 = (Dali::Property *) 0 ;
14793
14794   arg1 = (Dali::Property *)jarg1;
14795   {
14796     try {
14797       delete arg1;
14798     } catch (std::out_of_range& e) {
14799       {
14800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14801       };
14802     } catch (std::exception& e) {
14803       {
14804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (Dali::DaliException e) {
14807       {
14808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14809       };
14810     } catch (...) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14813       };
14814     }
14815   }
14816
14817 }
14818
14819
14820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14821   Dali::Property *arg1 = (Dali::Property *) 0 ;
14822   Dali::Handle *arg2 = 0 ;
14823
14824   arg1 = (Dali::Property *)jarg1;
14825   arg2 = (Dali::Handle *)jarg2;
14826   if (!arg2) {
14827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14828     return ;
14829   }
14830   if (arg1) (arg1)->object = *arg2;
14831 }
14832
14833
14834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14835   void * jresult ;
14836   Dali::Property *arg1 = (Dali::Property *) 0 ;
14837   Dali::Handle *result = 0 ;
14838
14839   arg1 = (Dali::Property *)jarg1;
14840   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14841   jresult = (void *)result;
14842   return jresult;
14843 }
14844
14845
14846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14847   Dali::Property *arg1 = (Dali::Property *) 0 ;
14848   Dali::Property::Index arg2 ;
14849
14850   arg1 = (Dali::Property *)jarg1;
14851   arg2 = (Dali::Property::Index)jarg2;
14852   if (arg1) (arg1)->propertyIndex = arg2;
14853 }
14854
14855
14856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14857   int jresult ;
14858   Dali::Property *arg1 = (Dali::Property *) 0 ;
14859   Dali::Property::Index result;
14860
14861   arg1 = (Dali::Property *)jarg1;
14862   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14863   jresult = result;
14864   return jresult;
14865 }
14866
14867
14868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14869   Dali::Property *arg1 = (Dali::Property *) 0 ;
14870   int arg2 ;
14871
14872   arg1 = (Dali::Property *)jarg1;
14873   arg2 = (int)jarg2;
14874   if (arg1) (arg1)->componentIndex = arg2;
14875 }
14876
14877
14878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14879   int jresult ;
14880   Dali::Property *arg1 = (Dali::Property *) 0 ;
14881   int result;
14882
14883   arg1 = (Dali::Property *)jarg1;
14884   result = (int) ((arg1)->componentIndex);
14885   jresult = result;
14886   return jresult;
14887 }
14888
14889
14890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14891   void * jresult ;
14892   Dali::Property::Array *result = 0 ;
14893
14894   {
14895     try {
14896       result = (Dali::Property::Array *)new Dali::Property::Array();
14897     } catch (std::out_of_range& e) {
14898       {
14899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14900       };
14901     } catch (std::exception& e) {
14902       {
14903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (Dali::DaliException e) {
14906       {
14907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14908       };
14909     } catch (...) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14912       };
14913     }
14914   }
14915
14916   jresult = (void *)result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14922   void * jresult ;
14923   Dali::Property::Array *arg1 = 0 ;
14924   Dali::Property::Array *result = 0 ;
14925
14926   arg1 = (Dali::Property::Array *)jarg1;
14927   if (!arg1) {
14928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14929     return 0;
14930   }
14931   {
14932     try {
14933       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14934     } catch (std::out_of_range& e) {
14935       {
14936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14937       };
14938     } catch (std::exception& e) {
14939       {
14940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (Dali::DaliException e) {
14943       {
14944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14945       };
14946     } catch (...) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14949       };
14950     }
14951   }
14952
14953   jresult = (void *)result;
14954   return jresult;
14955 }
14956
14957
14958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14959   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14960
14961   arg1 = (Dali::Property::Array *)jarg1;
14962   {
14963     try {
14964       delete arg1;
14965     } catch (std::out_of_range& e) {
14966       {
14967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14968       };
14969     } catch (std::exception& e) {
14970       {
14971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (Dali::DaliException e) {
14974       {
14975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14976       };
14977     } catch (...) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14980       };
14981     }
14982   }
14983
14984 }
14985
14986
14987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14988   unsigned long jresult ;
14989   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14990   Dali::Property::Array::SizeType result;
14991
14992   arg1 = (Dali::Property::Array *)jarg1;
14993   {
14994     try {
14995       result = ((Dali::Property::Array const *)arg1)->Size();
14996     } catch (std::out_of_range& e) {
14997       {
14998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14999       };
15000     } catch (std::exception& e) {
15001       {
15002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (Dali::DaliException e) {
15005       {
15006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15007       };
15008     } catch (...) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15011       };
15012     }
15013   }
15014
15015   jresult = (unsigned long)result;
15016   return jresult;
15017 }
15018
15019
15020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15021   unsigned long jresult ;
15022   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15023   Dali::Property::Array::SizeType result;
15024
15025   arg1 = (Dali::Property::Array *)jarg1;
15026   {
15027     try {
15028       result = ((Dali::Property::Array const *)arg1)->Count();
15029     } catch (std::out_of_range& e) {
15030       {
15031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15032       };
15033     } catch (std::exception& e) {
15034       {
15035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (Dali::DaliException e) {
15038       {
15039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15040       };
15041     } catch (...) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15044       };
15045     }
15046   }
15047
15048   jresult = (unsigned long)result;
15049   return jresult;
15050 }
15051
15052
15053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15054   unsigned int jresult ;
15055   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15056   bool result;
15057
15058   arg1 = (Dali::Property::Array *)jarg1;
15059   {
15060     try {
15061       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15062     } catch (std::out_of_range& e) {
15063       {
15064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15065       };
15066     } catch (std::exception& e) {
15067       {
15068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (Dali::DaliException e) {
15071       {
15072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15073       };
15074     } catch (...) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15077       };
15078     }
15079   }
15080
15081   jresult = result;
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15087   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15088
15089   arg1 = (Dali::Property::Array *)jarg1;
15090   {
15091     try {
15092       (arg1)->Clear();
15093     } catch (std::out_of_range& e) {
15094       {
15095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15096       };
15097     } catch (std::exception& e) {
15098       {
15099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (Dali::DaliException e) {
15102       {
15103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15104       };
15105     } catch (...) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15108       };
15109     }
15110   }
15111
15112 }
15113
15114
15115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15116   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15117   Dali::Property::Array::SizeType arg2 ;
15118
15119   arg1 = (Dali::Property::Array *)jarg1;
15120   arg2 = (Dali::Property::Array::SizeType)jarg2;
15121   {
15122     try {
15123       (arg1)->Reserve(arg2);
15124     } catch (std::out_of_range& e) {
15125       {
15126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15127       };
15128     } catch (std::exception& e) {
15129       {
15130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (Dali::DaliException e) {
15133       {
15134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15135       };
15136     } catch (...) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15139       };
15140     }
15141   }
15142
15143 }
15144
15145
15146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15147   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15148   Dali::Property::Array::SizeType arg2 ;
15149
15150   arg1 = (Dali::Property::Array *)jarg1;
15151   arg2 = (Dali::Property::Array::SizeType)jarg2;
15152   {
15153     try {
15154       (arg1)->Resize(arg2);
15155     } catch (std::out_of_range& e) {
15156       {
15157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15158       };
15159     } catch (std::exception& e) {
15160       {
15161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (Dali::DaliException e) {
15164       {
15165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15166       };
15167     } catch (...) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15170       };
15171     }
15172   }
15173
15174 }
15175
15176
15177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15178   unsigned long jresult ;
15179   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15180   Dali::Property::Array::SizeType result;
15181
15182   arg1 = (Dali::Property::Array *)jarg1;
15183   {
15184     try {
15185       result = (arg1)->Capacity();
15186     } catch (std::out_of_range& e) {
15187       {
15188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15189       };
15190     } catch (std::exception& e) {
15191       {
15192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (Dali::DaliException e) {
15195       {
15196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15197       };
15198     } catch (...) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15201       };
15202     }
15203   }
15204
15205   jresult = (unsigned long)result;
15206   return jresult;
15207 }
15208
15209
15210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15211   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15212   Dali::Property::Value *arg2 = 0 ;
15213
15214   arg1 = (Dali::Property::Array *)jarg1;
15215   arg2 = (Dali::Property::Value *)jarg2;
15216   if (!arg2) {
15217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15218     return ;
15219   }
15220   {
15221     try {
15222       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15223     } catch (std::out_of_range& e) {
15224       {
15225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15226       };
15227     } catch (std::exception& e) {
15228       {
15229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (Dali::DaliException e) {
15232       {
15233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15234       };
15235     } catch (...) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15238       };
15239     }
15240   }
15241
15242 }
15243
15244
15245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15246   void * jresult ;
15247   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15248   Dali::Property::Value *arg2 = 0 ;
15249   Dali::Property::Array *result = 0 ;
15250
15251   arg1 = (Dali::Property::Array *)jarg1;
15252   arg2 = (Dali::Property::Value *)jarg2;
15253   if (!arg2) {
15254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15255     return 0;
15256   }
15257   {
15258     try {
15259       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15260     } catch (std::out_of_range& e) {
15261       {
15262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15263       };
15264     } catch (std::exception& e) {
15265       {
15266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (Dali::DaliException e) {
15269       {
15270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15271       };
15272     } catch (...) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15275       };
15276     }
15277   }
15278
15279   jresult = (void *)result;
15280   return jresult;
15281 }
15282
15283
15284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15285   void * jresult ;
15286   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15287   Dali::Property::Array::SizeType arg2 ;
15288   Dali::Property::Value *result = 0 ;
15289
15290   arg1 = (Dali::Property::Array *)jarg1;
15291   arg2 = (Dali::Property::Array::SizeType)jarg2;
15292   {
15293     try {
15294       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15295     } catch (std::out_of_range& e) {
15296       {
15297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (std::exception& e) {
15300       {
15301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (Dali::DaliException e) {
15304       {
15305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15306       };
15307     } catch (...) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15310       };
15311     }
15312   }
15313
15314   jresult = (void *)result;
15315   return jresult;
15316 }
15317
15318
15319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15320   void * jresult ;
15321   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15322   Dali::Property::Array::SizeType arg2 ;
15323   Dali::Property::Value *result = 0 ;
15324
15325   arg1 = (Dali::Property::Array *)jarg1;
15326   arg2 = (Dali::Property::Array::SizeType)jarg2;
15327   {
15328     try {
15329       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15330     } catch (std::out_of_range& e) {
15331       {
15332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (std::exception& e) {
15335       {
15336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (Dali::DaliException e) {
15339       {
15340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15341       };
15342     } catch (...) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15345       };
15346     }
15347   }
15348
15349   jresult = (void *)result;
15350   return jresult;
15351 }
15352
15353
15354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15355   void * jresult ;
15356   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15357   Dali::Property::Array *arg2 = 0 ;
15358   Dali::Property::Array *result = 0 ;
15359
15360   arg1 = (Dali::Property::Array *)jarg1;
15361   arg2 = (Dali::Property::Array *)jarg2;
15362   if (!arg2) {
15363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15364     return 0;
15365   }
15366   {
15367     try {
15368       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15369     } catch (std::out_of_range& e) {
15370       {
15371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15372       };
15373     } catch (std::exception& e) {
15374       {
15375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (Dali::DaliException e) {
15378       {
15379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15380       };
15381     } catch (...) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15384       };
15385     }
15386   }
15387
15388   jresult = (void *)result;
15389   return jresult;
15390 }
15391
15392
15393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15394   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15395   enum Dali::Property::Key::Type arg2 ;
15396
15397   arg1 = (Dali::Property::Key *)jarg1;
15398   arg2 = (enum Dali::Property::Key::Type)jarg2;
15399   if (arg1) (arg1)->type = arg2;
15400 }
15401
15402
15403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15404   int jresult ;
15405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15406   enum Dali::Property::Key::Type result;
15407
15408   arg1 = (Dali::Property::Key *)jarg1;
15409   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15410   jresult = (int)result;
15411   return jresult;
15412 }
15413
15414
15415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   Dali::Property::Index arg2 ;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   arg2 = (Dali::Property::Index)jarg2;
15421   if (arg1) (arg1)->indexKey = arg2;
15422 }
15423
15424
15425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15426   int jresult ;
15427   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15428   Dali::Property::Index result;
15429
15430   arg1 = (Dali::Property::Key *)jarg1;
15431   result = (Dali::Property::Index) ((arg1)->indexKey);
15432   jresult = result;
15433   return jresult;
15434 }
15435
15436
15437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15438   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15439   std::string *arg2 = 0 ;
15440
15441   arg1 = (Dali::Property::Key *)jarg1;
15442   if (!jarg2) {
15443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15444     return ;
15445   }
15446   std::string arg2_str(jarg2);
15447   arg2 = &arg2_str;
15448   if (arg1) (arg1)->stringKey = *arg2;
15449
15450   //argout typemap for const std::string&
15451
15452 }
15453
15454
15455 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15456   char * jresult ;
15457   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15458   std::string *result = 0 ;
15459
15460   arg1 = (Dali::Property::Key *)jarg1;
15461   result = (std::string *) & ((arg1)->stringKey);
15462   jresult = SWIG_csharp_string_callback(result->c_str());
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15468   void * jresult ;
15469   std::string *arg1 = 0 ;
15470   Dali::Property::Key *result = 0 ;
15471
15472   if (!jarg1) {
15473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15474     return 0;
15475   }
15476   std::string arg1_str(jarg1);
15477   arg1 = &arg1_str;
15478   {
15479     try {
15480       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15481     } catch (std::out_of_range& e) {
15482       {
15483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15484       };
15485     } catch (std::exception& e) {
15486       {
15487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (Dali::DaliException e) {
15490       {
15491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15492       };
15493     } catch (...) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15496       };
15497     }
15498   }
15499
15500   jresult = (void *)result;
15501
15502   //argout typemap for const std::string&
15503
15504   return jresult;
15505 }
15506
15507
15508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15509   void * jresult ;
15510   Dali::Property::Index arg1 ;
15511   Dali::Property::Key *result = 0 ;
15512
15513   arg1 = (Dali::Property::Index)jarg1;
15514   {
15515     try {
15516       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15517     } catch (std::out_of_range& e) {
15518       {
15519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15520       };
15521     } catch (std::exception& e) {
15522       {
15523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (Dali::DaliException e) {
15526       {
15527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15528       };
15529     } catch (...) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15532       };
15533     }
15534   }
15535
15536   jresult = (void *)result;
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15542   unsigned int jresult ;
15543   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15544   std::string *arg2 = 0 ;
15545   bool result;
15546
15547   arg1 = (Dali::Property::Key *)jarg1;
15548   if (!jarg2) {
15549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15550     return 0;
15551   }
15552   std::string arg2_str(jarg2);
15553   arg2 = &arg2_str;
15554   {
15555     try {
15556       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15557     } catch (std::out_of_range& e) {
15558       {
15559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15560       };
15561     } catch (std::exception& e) {
15562       {
15563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (Dali::DaliException e) {
15566       {
15567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15568       };
15569     } catch (...) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15572       };
15573     }
15574   }
15575
15576   jresult = result;
15577
15578   //argout typemap for const std::string&
15579
15580   return jresult;
15581 }
15582
15583
15584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15585   unsigned int jresult ;
15586   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15587   Dali::Property::Index arg2 ;
15588   bool result;
15589
15590   arg1 = (Dali::Property::Key *)jarg1;
15591   arg2 = (Dali::Property::Index)jarg2;
15592   {
15593     try {
15594       result = (bool)(arg1)->operator ==(arg2);
15595     } catch (std::out_of_range& e) {
15596       {
15597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15598       };
15599     } catch (std::exception& e) {
15600       {
15601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (Dali::DaliException e) {
15604       {
15605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15606       };
15607     } catch (...) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15610       };
15611     }
15612   }
15613
15614   jresult = result;
15615   return jresult;
15616 }
15617
15618
15619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15620   unsigned int jresult ;
15621   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15622   Dali::Property::Key *arg2 = 0 ;
15623   bool result;
15624
15625   arg1 = (Dali::Property::Key *)jarg1;
15626   arg2 = (Dali::Property::Key *)jarg2;
15627   if (!arg2) {
15628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15629     return 0;
15630   }
15631   {
15632     try {
15633       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15634     } catch (std::out_of_range& e) {
15635       {
15636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15637       };
15638     } catch (std::exception& e) {
15639       {
15640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (Dali::DaliException e) {
15643       {
15644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652
15653   jresult = result;
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15661   std::string *arg2 = 0 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Key *)jarg1;
15665   if (!jarg2) {
15666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15667     return 0;
15668   }
15669   std::string arg2_str(jarg2);
15670   arg2 = &arg2_str;
15671   {
15672     try {
15673       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15674     } catch (std::out_of_range& e) {
15675       {
15676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15677       };
15678     } catch (std::exception& e) {
15679       {
15680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (Dali::DaliException e) {
15683       {
15684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15685       };
15686     } catch (...) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15689       };
15690     }
15691   }
15692
15693   jresult = result;
15694
15695   //argout typemap for const std::string&
15696
15697   return jresult;
15698 }
15699
15700
15701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15702   unsigned int jresult ;
15703   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15704   Dali::Property::Index arg2 ;
15705   bool result;
15706
15707   arg1 = (Dali::Property::Key *)jarg1;
15708   arg2 = (Dali::Property::Index)jarg2;
15709   {
15710     try {
15711       result = (bool)(arg1)->operator !=(arg2);
15712     } catch (std::out_of_range& e) {
15713       {
15714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (std::exception& e) {
15717       {
15718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (Dali::DaliException e) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15723       };
15724     } catch (...) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15727       };
15728     }
15729   }
15730
15731   jresult = result;
15732   return jresult;
15733 }
15734
15735
15736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15737   unsigned int jresult ;
15738   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15739   Dali::Property::Key *arg2 = 0 ;
15740   bool result;
15741
15742   arg1 = (Dali::Property::Key *)jarg1;
15743   arg2 = (Dali::Property::Key *)jarg2;
15744   if (!arg2) {
15745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15746     return 0;
15747   }
15748   {
15749     try {
15750       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15751     } catch (std::out_of_range& e) {
15752       {
15753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15754       };
15755     } catch (std::exception& e) {
15756       {
15757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (Dali::DaliException e) {
15760       {
15761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15762       };
15763     } catch (...) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15766       };
15767     }
15768   }
15769
15770   jresult = result;
15771   return jresult;
15772 }
15773
15774
15775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15776   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15777
15778   arg1 = (Dali::Property::Key *)jarg1;
15779   {
15780     try {
15781       delete arg1;
15782     } catch (std::out_of_range& e) {
15783       {
15784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15785       };
15786     } catch (std::exception& e) {
15787       {
15788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (Dali::DaliException e) {
15791       {
15792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15793       };
15794     } catch (...) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15797       };
15798     }
15799   }
15800
15801 }
15802
15803
15804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15805   void * jresult ;
15806   Dali::Property::Map *result = 0 ;
15807
15808   {
15809     try {
15810       result = (Dali::Property::Map *)new Dali::Property::Map();
15811     } catch (std::out_of_range& e) {
15812       {
15813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (std::exception& e) {
15816       {
15817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (Dali::DaliException e) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15822       };
15823     } catch (...) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15826       };
15827     }
15828   }
15829
15830   jresult = (void *)result;
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15836   void * jresult ;
15837   Dali::Property::Map *arg1 = 0 ;
15838   Dali::Property::Map *result = 0 ;
15839
15840   arg1 = (Dali::Property::Map *)jarg1;
15841   if (!arg1) {
15842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15843     return 0;
15844   }
15845   {
15846     try {
15847       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15848     } catch (std::out_of_range& e) {
15849       {
15850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15851       };
15852     } catch (std::exception& e) {
15853       {
15854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (Dali::DaliException e) {
15857       {
15858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15859       };
15860     } catch (...) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15863       };
15864     }
15865   }
15866
15867   jresult = (void *)result;
15868   return jresult;
15869 }
15870
15871
15872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15873   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15874
15875   arg1 = (Dali::Property::Map *)jarg1;
15876   {
15877     try {
15878       delete arg1;
15879     } catch (std::out_of_range& e) {
15880       {
15881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15882       };
15883     } catch (std::exception& e) {
15884       {
15885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (Dali::DaliException e) {
15888       {
15889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15890       };
15891     } catch (...) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15894       };
15895     }
15896   }
15897
15898 }
15899
15900
15901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15902   unsigned long jresult ;
15903   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15904   Dali::Property::Map::SizeType result;
15905
15906   arg1 = (Dali::Property::Map *)jarg1;
15907   {
15908     try {
15909       result = ((Dali::Property::Map const *)arg1)->Count();
15910     } catch (std::out_of_range& e) {
15911       {
15912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15913       };
15914     } catch (std::exception& e) {
15915       {
15916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (Dali::DaliException e) {
15919       {
15920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15921       };
15922     } catch (...) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15925       };
15926     }
15927   }
15928
15929   jresult = (unsigned long)result;
15930   return jresult;
15931 }
15932
15933
15934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15935   unsigned int jresult ;
15936   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15937   bool result;
15938
15939   arg1 = (Dali::Property::Map *)jarg1;
15940   {
15941     try {
15942       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15943     } catch (std::out_of_range& e) {
15944       {
15945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15946       };
15947     } catch (std::exception& e) {
15948       {
15949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (Dali::DaliException e) {
15952       {
15953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15954       };
15955     } catch (...) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15958       };
15959     }
15960   }
15961
15962   jresult = result;
15963   return jresult;
15964 }
15965
15966
15967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15968   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15969   char *arg2 = (char *) 0 ;
15970   Dali::Property::Value *arg3 = 0 ;
15971
15972   arg1 = (Dali::Property::Map *)jarg1;
15973   arg2 = (char *)jarg2;
15974   arg3 = (Dali::Property::Value *)jarg3;
15975   if (!arg3) {
15976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15977     return ;
15978   }
15979   {
15980     try {
15981       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15982     } catch (std::out_of_range& e) {
15983       {
15984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15985       };
15986     } catch (std::exception& e) {
15987       {
15988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (Dali::DaliException e) {
15991       {
15992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15993       };
15994     } catch (...) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15997       };
15998     }
15999   }
16000
16001 }
16002
16003
16004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16005   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16006   Dali::Property::Index arg2 ;
16007   Dali::Property::Value *arg3 = 0 ;
16008
16009   arg1 = (Dali::Property::Map *)jarg1;
16010   arg2 = (Dali::Property::Index)jarg2;
16011   arg3 = (Dali::Property::Value *)jarg3;
16012   if (!arg3) {
16013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16014     return ;
16015   }
16016   {
16017     try {
16018       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16019     } catch (std::out_of_range& e) {
16020       {
16021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16022       };
16023     } catch (std::exception& e) {
16024       {
16025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (Dali::DaliException e) {
16028       {
16029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16030       };
16031     } catch (...) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16034       };
16035     }
16036   }
16037
16038 }
16039
16040
16041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16042   void * jresult ;
16043   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16044   char *arg2 = (char *) 0 ;
16045   Dali::Property::Value *arg3 = 0 ;
16046   Dali::Property::Map *result = 0 ;
16047
16048   arg1 = (Dali::Property::Map *)jarg1;
16049   arg2 = (char *)jarg2;
16050   arg3 = (Dali::Property::Value *)jarg3;
16051   if (!arg3) {
16052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16053     return 0;
16054   }
16055   {
16056     try {
16057       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16058     } catch (std::out_of_range& e) {
16059       {
16060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16061       };
16062     } catch (std::exception& e) {
16063       {
16064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (Dali::DaliException e) {
16067       {
16068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16069       };
16070     } catch (...) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16073       };
16074     }
16075   }
16076
16077   jresult = (void *)result;
16078   return jresult;
16079 }
16080
16081
16082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16083   void * jresult ;
16084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16085   Dali::Property::Index arg2 ;
16086   Dali::Property::Value *arg3 = 0 ;
16087   Dali::Property::Map *result = 0 ;
16088
16089   arg1 = (Dali::Property::Map *)jarg1;
16090   arg2 = (Dali::Property::Index)jarg2;
16091   arg3 = (Dali::Property::Value *)jarg3;
16092   if (!arg3) {
16093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16094     return 0;
16095   }
16096   {
16097     try {
16098       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16099     } catch (std::out_of_range& e) {
16100       {
16101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16102       };
16103     } catch (std::exception& e) {
16104       {
16105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (Dali::DaliException e) {
16108       {
16109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16110       };
16111     } catch (...) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16114       };
16115     }
16116   }
16117
16118   jresult = (void *)result;
16119   return jresult;
16120 }
16121
16122
16123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16124   void * jresult ;
16125   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16126   Dali::Property::Map::SizeType arg2 ;
16127   Dali::Property::Value *result = 0 ;
16128
16129   arg1 = (Dali::Property::Map *)jarg1;
16130   arg2 = (Dali::Property::Map::SizeType)jarg2;
16131   {
16132     try {
16133       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16134     } catch (std::out_of_range& e) {
16135       {
16136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16137       };
16138     } catch (std::exception& e) {
16139       {
16140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (Dali::DaliException e) {
16143       {
16144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16145       };
16146     } catch (...) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16149       };
16150     }
16151   }
16152
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16159   char * jresult ;
16160   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16161   Dali::Property::Map::SizeType arg2 ;
16162   std::string *result = 0 ;
16163
16164   arg1 = (Dali::Property::Map *)jarg1;
16165   arg2 = (Dali::Property::Map::SizeType)jarg2;
16166   {
16167     try {
16168       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16169     } catch (std::out_of_range& e) {
16170       {
16171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16172       };
16173     } catch (std::exception& e) {
16174       {
16175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (Dali::DaliException e) {
16178       {
16179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16180       };
16181     } catch (...) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16184       };
16185     }
16186   }
16187
16188   jresult = SWIG_csharp_string_callback(result->c_str());
16189   return jresult;
16190 }
16191
16192
16193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16194   void * jresult ;
16195   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16196   Dali::Property::Map::SizeType arg2 ;
16197   SwigValueWrapper< Dali::Property::Key > result;
16198
16199   arg1 = (Dali::Property::Map *)jarg1;
16200   arg2 = (Dali::Property::Map::SizeType)jarg2;
16201   {
16202     try {
16203       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16204     } catch (std::out_of_range& e) {
16205       {
16206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16207       };
16208     } catch (std::exception& e) {
16209       {
16210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (Dali::DaliException e) {
16213       {
16214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16215       };
16216     } catch (...) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16219       };
16220     }
16221   }
16222
16223   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16224   return jresult;
16225 }
16226
16227
16228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16229   void * jresult ;
16230   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16231   Dali::Property::Map::SizeType arg2 ;
16232   StringValuePair *result = 0 ;
16233
16234   arg1 = (Dali::Property::Map *)jarg1;
16235   arg2 = (Dali::Property::Map::SizeType)jarg2;
16236   {
16237     try {
16238       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16239     } catch (std::out_of_range& e) {
16240       {
16241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16242       };
16243     } catch (std::exception& e) {
16244       {
16245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (Dali::DaliException e) {
16248       {
16249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16250       };
16251     } catch (...) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16254       };
16255     }
16256   }
16257
16258   jresult = (void *)result;
16259   return jresult;
16260 }
16261
16262
16263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16264   void * jresult ;
16265   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16266   char *arg2 = (char *) 0 ;
16267   Dali::Property::Value *result = 0 ;
16268
16269   arg1 = (Dali::Property::Map *)jarg1;
16270   arg2 = (char *)jarg2;
16271   {
16272     try {
16273       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16274     } catch (std::out_of_range& e) {
16275       {
16276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16277       };
16278     } catch (std::exception& e) {
16279       {
16280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (Dali::DaliException e) {
16283       {
16284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16285       };
16286     } catch (...) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16289       };
16290     }
16291   }
16292
16293   jresult = (void *)result;
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16299   void * jresult ;
16300   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16301   Dali::Property::Index arg2 ;
16302   Dali::Property::Value *result = 0 ;
16303
16304   arg1 = (Dali::Property::Map *)jarg1;
16305   arg2 = (Dali::Property::Index)jarg2;
16306   {
16307     try {
16308       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16309     } catch (std::out_of_range& e) {
16310       {
16311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16312       };
16313     } catch (std::exception& e) {
16314       {
16315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (Dali::DaliException e) {
16318       {
16319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16320       };
16321     } catch (...) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16324       };
16325     }
16326   }
16327
16328   jresult = (void *)result;
16329   return jresult;
16330 }
16331
16332
16333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16334   void * jresult ;
16335   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16336   Dali::Property::Index arg2 ;
16337   std::string *arg3 = 0 ;
16338   Dali::Property::Value *result = 0 ;
16339
16340   arg1 = (Dali::Property::Map *)jarg1;
16341   arg2 = (Dali::Property::Index)jarg2;
16342   if (!jarg3) {
16343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16344     return 0;
16345   }
16346   std::string arg3_str(jarg3);
16347   arg3 = &arg3_str;
16348   {
16349     try {
16350       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16351     } catch (std::out_of_range& e) {
16352       {
16353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (std::exception& e) {
16356       {
16357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (Dali::DaliException e) {
16360       {
16361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16362       };
16363     } catch (...) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16366       };
16367     }
16368   }
16369
16370   jresult = (void *)result;
16371
16372   //argout typemap for const std::string&
16373
16374   return jresult;
16375 }
16376
16377
16378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16379   void * jresult ;
16380   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16381   std::string *arg2 = 0 ;
16382   Dali::Property::Type arg3 ;
16383   Dali::Property::Value *result = 0 ;
16384
16385   arg1 = (Dali::Property::Map *)jarg1;
16386   if (!jarg2) {
16387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16388     return 0;
16389   }
16390   std::string arg2_str(jarg2);
16391   arg2 = &arg2_str;
16392   arg3 = (Dali::Property::Type)jarg3;
16393   {
16394     try {
16395       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16396     } catch (std::out_of_range& e) {
16397       {
16398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16399       };
16400     } catch (std::exception& e) {
16401       {
16402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (Dali::DaliException e) {
16405       {
16406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16407       };
16408     } catch (...) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16411       };
16412     }
16413   }
16414
16415   jresult = (void *)result;
16416
16417   //argout typemap for const std::string&
16418
16419   return jresult;
16420 }
16421
16422
16423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16424   void * jresult ;
16425   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16426   Dali::Property::Index arg2 ;
16427   Dali::Property::Type arg3 ;
16428   Dali::Property::Value *result = 0 ;
16429
16430   arg1 = (Dali::Property::Map *)jarg1;
16431   arg2 = (Dali::Property::Index)jarg2;
16432   arg3 = (Dali::Property::Type)jarg3;
16433   {
16434     try {
16435       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16436     } catch (std::out_of_range& e) {
16437       {
16438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16439       };
16440     } catch (std::exception& e) {
16441       {
16442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (Dali::DaliException e) {
16445       {
16446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16447       };
16448     } catch (...) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16451       };
16452     }
16453   }
16454
16455   jresult = (void *)result;
16456   return jresult;
16457 }
16458
16459
16460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16461   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16462
16463   arg1 = (Dali::Property::Map *)jarg1;
16464   {
16465     try {
16466       (arg1)->Clear();
16467     } catch (std::out_of_range& e) {
16468       {
16469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16470       };
16471     } catch (std::exception& e) {
16472       {
16473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (Dali::DaliException e) {
16476       {
16477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16478       };
16479     } catch (...) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16482       };
16483     }
16484   }
16485
16486 }
16487
16488
16489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16490   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16491   Dali::Property::Map *arg2 = 0 ;
16492
16493   arg1 = (Dali::Property::Map *)jarg1;
16494   arg2 = (Dali::Property::Map *)jarg2;
16495   if (!arg2) {
16496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16497     return ;
16498   }
16499   {
16500     try {
16501       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16502     } catch (std::out_of_range& e) {
16503       {
16504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16505       };
16506     } catch (std::exception& e) {
16507       {
16508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (Dali::DaliException e) {
16511       {
16512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16513       };
16514     } catch (...) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16517       };
16518     }
16519   }
16520
16521 }
16522
16523
16524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16525   void * jresult ;
16526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16527   std::string *arg2 = 0 ;
16528   Dali::Property::Value *result = 0 ;
16529
16530   arg1 = (Dali::Property::Map *)jarg1;
16531   if (!jarg2) {
16532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16533     return 0;
16534   }
16535   std::string arg2_str(jarg2);
16536   arg2 = &arg2_str;
16537   {
16538     try {
16539       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16540     } catch (std::out_of_range& e) {
16541       {
16542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16543       };
16544     } catch (std::exception& e) {
16545       {
16546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (Dali::DaliException e) {
16549       {
16550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16551       };
16552     } catch (...) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16555       };
16556     }
16557   }
16558
16559   jresult = (void *)result;
16560
16561   //argout typemap for const std::string&
16562
16563   return jresult;
16564 }
16565
16566
16567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16568   void * jresult ;
16569   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16570   Dali::Property::Index arg2 ;
16571   Dali::Property::Value *result = 0 ;
16572
16573   arg1 = (Dali::Property::Map *)jarg1;
16574   arg2 = (Dali::Property::Index)jarg2;
16575   {
16576     try {
16577       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16578     } catch (std::out_of_range& e) {
16579       {
16580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (std::exception& e) {
16583       {
16584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (Dali::DaliException e) {
16587       {
16588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16589       };
16590     } catch (...) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16593       };
16594     }
16595   }
16596
16597   jresult = (void *)result;
16598   return jresult;
16599 }
16600
16601
16602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16603   void * jresult ;
16604   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16605   Dali::Property::Map *arg2 = 0 ;
16606   Dali::Property::Map *result = 0 ;
16607
16608   arg1 = (Dali::Property::Map *)jarg1;
16609   arg2 = (Dali::Property::Map *)jarg2;
16610   if (!arg2) {
16611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16612     return 0;
16613   }
16614   {
16615     try {
16616       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16617     } catch (std::out_of_range& e) {
16618       {
16619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16620       };
16621     } catch (std::exception& e) {
16622       {
16623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (Dali::DaliException e) {
16626       {
16627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16628       };
16629     } catch (...) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16632       };
16633     }
16634   }
16635
16636   jresult = (void *)result;
16637   return jresult;
16638 }
16639
16640
16641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16642   void * jresult ;
16643   Dali::Property::Value *result = 0 ;
16644
16645   {
16646     try {
16647       result = (Dali::Property::Value *)new Dali::Property::Value();
16648     } catch (std::out_of_range& e) {
16649       {
16650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16651       };
16652     } catch (std::exception& e) {
16653       {
16654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (Dali::DaliException e) {
16657       {
16658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16659       };
16660     } catch (...) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16663       };
16664     }
16665   }
16666
16667   jresult = (void *)result;
16668   return jresult;
16669 }
16670
16671
16672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16673   void * jresult ;
16674   bool arg1 ;
16675   Dali::Property::Value *result = 0 ;
16676
16677   arg1 = jarg1 ? true : false;
16678   {
16679     try {
16680       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16681     } catch (std::out_of_range& e) {
16682       {
16683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16684       };
16685     } catch (std::exception& e) {
16686       {
16687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (Dali::DaliException e) {
16690       {
16691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16692       };
16693     } catch (...) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16696       };
16697     }
16698   }
16699
16700   jresult = (void *)result;
16701   return jresult;
16702 }
16703
16704
16705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16706   void * jresult ;
16707   int arg1 ;
16708   Dali::Property::Value *result = 0 ;
16709
16710   arg1 = (int)jarg1;
16711   {
16712     try {
16713       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16714     } catch (std::out_of_range& e) {
16715       {
16716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16717       };
16718     } catch (std::exception& e) {
16719       {
16720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (Dali::DaliException e) {
16723       {
16724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16725       };
16726     } catch (...) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16729       };
16730     }
16731   }
16732
16733   jresult = (void *)result;
16734   return jresult;
16735 }
16736
16737
16738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16739   void * jresult ;
16740   float arg1 ;
16741   Dali::Property::Value *result = 0 ;
16742
16743   arg1 = (float)jarg1;
16744   {
16745     try {
16746       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16747     } catch (std::out_of_range& e) {
16748       {
16749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16750       };
16751     } catch (std::exception& e) {
16752       {
16753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (Dali::DaliException e) {
16756       {
16757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16758       };
16759     } catch (...) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16762       };
16763     }
16764   }
16765
16766   jresult = (void *)result;
16767   return jresult;
16768 }
16769
16770
16771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16772   void * jresult ;
16773   Dali::Vector2 *arg1 = 0 ;
16774   Dali::Property::Value *result = 0 ;
16775
16776   arg1 = (Dali::Vector2 *)jarg1;
16777   if (!arg1) {
16778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16779     return 0;
16780   }
16781   {
16782     try {
16783       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16784     } catch (std::out_of_range& e) {
16785       {
16786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16787       };
16788     } catch (std::exception& e) {
16789       {
16790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (Dali::DaliException e) {
16793       {
16794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16795       };
16796     } catch (...) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16799       };
16800     }
16801   }
16802
16803   jresult = (void *)result;
16804   return jresult;
16805 }
16806
16807
16808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16809   void * jresult ;
16810   Dali::Vector3 *arg1 = 0 ;
16811   Dali::Property::Value *result = 0 ;
16812
16813   arg1 = (Dali::Vector3 *)jarg1;
16814   if (!arg1) {
16815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16816     return 0;
16817   }
16818   {
16819     try {
16820       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (Dali::DaliException e) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16832       };
16833     } catch (...) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16836       };
16837     }
16838   }
16839
16840   jresult = (void *)result;
16841   return jresult;
16842 }
16843
16844
16845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16846   void * jresult ;
16847   Dali::Vector4 *arg1 = 0 ;
16848   Dali::Property::Value *result = 0 ;
16849
16850   arg1 = (Dali::Vector4 *)jarg1;
16851   if (!arg1) {
16852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16853     return 0;
16854   }
16855   {
16856     try {
16857       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16858     } catch (std::out_of_range& e) {
16859       {
16860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16861       };
16862     } catch (std::exception& e) {
16863       {
16864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (Dali::DaliException e) {
16867       {
16868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16869       };
16870     } catch (...) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16873       };
16874     }
16875   }
16876
16877   jresult = (void *)result;
16878   return jresult;
16879 }
16880
16881
16882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16883   void * jresult ;
16884   Dali::Matrix3 *arg1 = 0 ;
16885   Dali::Property::Value *result = 0 ;
16886
16887   arg1 = (Dali::Matrix3 *)jarg1;
16888   if (!arg1) {
16889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16890     return 0;
16891   }
16892   {
16893     try {
16894       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (Dali::DaliException e) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16906       };
16907     } catch (...) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16910       };
16911     }
16912   }
16913
16914   jresult = (void *)result;
16915   return jresult;
16916 }
16917
16918
16919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16920   void * jresult ;
16921   Dali::Matrix *arg1 = 0 ;
16922   Dali::Property::Value *result = 0 ;
16923
16924   arg1 = (Dali::Matrix *)jarg1;
16925   if (!arg1) {
16926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16927     return 0;
16928   }
16929   {
16930     try {
16931       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16932     } catch (std::out_of_range& e) {
16933       {
16934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16935       };
16936     } catch (std::exception& e) {
16937       {
16938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (Dali::DaliException e) {
16941       {
16942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16943       };
16944     } catch (...) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16947       };
16948     }
16949   }
16950
16951   jresult = (void *)result;
16952   return jresult;
16953 }
16954
16955
16956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16957   void * jresult ;
16958   Dali::Rect< int > *arg1 = 0 ;
16959   Dali::Property::Value *result = 0 ;
16960
16961   arg1 = (Dali::Rect< int > *)jarg1;
16962   if (!arg1) {
16963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16964     return 0;
16965   }
16966   {
16967     try {
16968       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16969     } catch (std::out_of_range& e) {
16970       {
16971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16972       };
16973     } catch (std::exception& e) {
16974       {
16975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (Dali::DaliException e) {
16978       {
16979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16980       };
16981     } catch (...) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16984       };
16985     }
16986   }
16987
16988   jresult = (void *)result;
16989   return jresult;
16990 }
16991
16992
16993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16994   void * jresult ;
16995   Dali::AngleAxis *arg1 = 0 ;
16996   Dali::Property::Value *result = 0 ;
16997
16998   arg1 = (Dali::AngleAxis *)jarg1;
16999   if (!arg1) {
17000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17001     return 0;
17002   }
17003   {
17004     try {
17005       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17006     } catch (std::out_of_range& e) {
17007       {
17008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17009       };
17010     } catch (std::exception& e) {
17011       {
17012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (Dali::DaliException e) {
17015       {
17016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17031   void * jresult ;
17032   Dali::Quaternion *arg1 = 0 ;
17033   Dali::Property::Value *result = 0 ;
17034
17035   arg1 = (Dali::Quaternion *)jarg1;
17036   if (!arg1) {
17037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17038     return 0;
17039   }
17040   {
17041     try {
17042       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17043     } catch (std::out_of_range& e) {
17044       {
17045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (std::exception& e) {
17048       {
17049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (Dali::DaliException e) {
17052       {
17053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17054       };
17055     } catch (...) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17058       };
17059     }
17060   }
17061
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066
17067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17068   void * jresult ;
17069   std::string *arg1 = 0 ;
17070   Dali::Property::Value *result = 0 ;
17071
17072   if (!jarg1) {
17073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17074     return 0;
17075   }
17076   std::string arg1_str(jarg1);
17077   arg1 = &arg1_str;
17078   {
17079     try {
17080       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17081     } catch (std::out_of_range& e) {
17082       {
17083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17084       };
17085     } catch (std::exception& e) {
17086       {
17087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (Dali::DaliException e) {
17090       {
17091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17092       };
17093     } catch (...) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17096       };
17097     }
17098   }
17099
17100   jresult = (void *)result;
17101
17102   //argout typemap for const std::string&
17103
17104   return jresult;
17105 }
17106
17107
17108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17109   void * jresult ;
17110   Dali::Property::Array *arg1 = 0 ;
17111   Dali::Property::Value *result = 0 ;
17112
17113   arg1 = (Dali::Property::Array *)jarg1;
17114   if (!arg1) {
17115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17116     return 0;
17117   }
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17146   void * jresult ;
17147   Dali::Property::Map *arg1 = 0 ;
17148   Dali::Property::Value *result = 0 ;
17149
17150   arg1 = (Dali::Property::Map *)jarg1;
17151   if (!arg1) {
17152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17153     return 0;
17154   }
17155   {
17156     try {
17157       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17158     } catch (std::out_of_range& e) {
17159       {
17160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (std::exception& e) {
17163       {
17164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (Dali::DaliException e) {
17167       {
17168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17169       };
17170     } catch (...) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17173       };
17174     }
17175   }
17176
17177   jresult = (void *)result;
17178   return jresult;
17179 }
17180
17181
17182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17183   void * jresult ;
17184   Extents *arg1 = 0 ;
17185   Dali::Property::Value *result = 0 ;
17186
17187   arg1 = (Extents *)jarg1;
17188   if (!arg1) {
17189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17190     return 0;
17191   }
17192   {
17193     try {
17194       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17195     } catch (std::out_of_range& e) {
17196       {
17197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17198       };
17199     } catch (std::exception& e) {
17200       {
17201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (...) {
17204       {
17205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17206       };
17207     }
17208   }
17209   jresult = (void *)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17215   void * jresult ;
17216   Dali::Property::Type arg1 ;
17217   Dali::Property::Value *result = 0 ;
17218
17219   arg1 = (Dali::Property::Type)jarg1;
17220   {
17221     try {
17222       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17223     } catch (std::out_of_range& e) {
17224       {
17225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17226       };
17227     } catch (std::exception& e) {
17228       {
17229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (Dali::DaliException e) {
17232       {
17233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17234       };
17235     } catch (...) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17238       };
17239     }
17240   }
17241
17242   jresult = (void *)result;
17243   return jresult;
17244 }
17245
17246
17247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17248   void * jresult ;
17249   Dali::Property::Value *arg1 = 0 ;
17250   Dali::Property::Value *result = 0 ;
17251
17252   arg1 = (Dali::Property::Value *)jarg1;
17253   if (!arg1) {
17254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17255     return 0;
17256   }
17257   {
17258     try {
17259       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17260     } catch (std::out_of_range& e) {
17261       {
17262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17263       };
17264     } catch (std::exception& e) {
17265       {
17266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (Dali::DaliException e) {
17269       {
17270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17271       };
17272     } catch (...) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17275       };
17276     }
17277   }
17278
17279   jresult = (void *)result;
17280   return jresult;
17281 }
17282
17283
17284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17285   void * jresult ;
17286   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17287   Dali::Property::Value *arg2 = 0 ;
17288   Dali::Property::Value *result = 0 ;
17289
17290   arg1 = (Dali::Property::Value *)jarg1;
17291   arg2 = (Dali::Property::Value *)jarg2;
17292   if (!arg2) {
17293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17294     return 0;
17295   }
17296   {
17297     try {
17298       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17299     } catch (std::out_of_range& e) {
17300       {
17301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17302       };
17303     } catch (std::exception& e) {
17304       {
17305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (Dali::DaliException e) {
17308       {
17309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17310       };
17311     } catch (...) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17314       };
17315     }
17316   }
17317
17318   jresult = (void *)result;
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17324   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17325
17326   arg1 = (Dali::Property::Value *)jarg1;
17327   {
17328     try {
17329       delete arg1;
17330     } catch (std::out_of_range& e) {
17331       {
17332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17333       };
17334     } catch (std::exception& e) {
17335       {
17336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (Dali::DaliException e) {
17339       {
17340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17345       };
17346     }
17347   }
17348
17349 }
17350
17351
17352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17353   int jresult ;
17354   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17355   Dali::Property::Type result;
17356
17357   arg1 = (Dali::Property::Value *)jarg1;
17358   {
17359     try {
17360       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17361     } catch (std::out_of_range& e) {
17362       {
17363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (std::exception& e) {
17366       {
17367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (Dali::DaliException e) {
17370       {
17371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17372       };
17373     } catch (...) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17376       };
17377     }
17378   }
17379
17380   jresult = (int)result;
17381   return jresult;
17382 }
17383
17384
17385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17386   unsigned int jresult ;
17387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17388   bool *arg2 = 0 ;
17389   bool result;
17390
17391   arg1 = (Dali::Property::Value *)jarg1;
17392   arg2 = (bool *)jarg2;
17393   {
17394     try {
17395       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17396     } catch (std::out_of_range& e) {
17397       {
17398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17399       };
17400     } catch (std::exception& e) {
17401       {
17402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (Dali::DaliException e) {
17405       {
17406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17407       };
17408     } catch (...) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17411       };
17412     }
17413   }
17414
17415   jresult = result;
17416   return jresult;
17417 }
17418
17419
17420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17421   unsigned int jresult ;
17422   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17423   float *arg2 = 0 ;
17424   bool result;
17425
17426   arg1 = (Dali::Property::Value *)jarg1;
17427   arg2 = (float *)jarg2;
17428   {
17429     try {
17430       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17431     } catch (std::out_of_range& e) {
17432       {
17433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17434       };
17435     } catch (std::exception& e) {
17436       {
17437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (Dali::DaliException e) {
17440       {
17441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17442       };
17443     } catch (...) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17446       };
17447     }
17448   }
17449
17450   jresult = result;
17451   return jresult;
17452 }
17453
17454
17455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17456   unsigned int jresult ;
17457   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17458   int *arg2 = 0 ;
17459   bool result;
17460
17461   arg1 = (Dali::Property::Value *)jarg1;
17462   arg2 = (int *)jarg2;
17463   {
17464     try {
17465       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17466     } catch (std::out_of_range& e) {
17467       {
17468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17469       };
17470     } catch (std::exception& e) {
17471       {
17472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (Dali::DaliException e) {
17475       {
17476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17477       };
17478     } catch (...) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17481       };
17482     }
17483   }
17484
17485   jresult = result;
17486   return jresult;
17487 }
17488
17489
17490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17491   unsigned int jresult ;
17492   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17493   Dali::Rect< int > *arg2 = 0 ;
17494   bool result;
17495
17496   arg1 = (Dali::Property::Value *)jarg1;
17497   arg2 = (Dali::Rect< int > *)jarg2;
17498   if (!arg2) {
17499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17500     return 0;
17501   }
17502   {
17503     try {
17504       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17505     } catch (std::out_of_range& e) {
17506       {
17507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17508       };
17509     } catch (std::exception& e) {
17510       {
17511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (Dali::DaliException e) {
17514       {
17515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17516       };
17517     } catch (...) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17520       };
17521     }
17522   }
17523
17524   jresult = result;
17525   return jresult;
17526 }
17527
17528
17529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17530   unsigned int jresult ;
17531   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17532   Dali::Vector2 *arg2 = 0 ;
17533   bool result;
17534
17535   arg1 = (Dali::Property::Value *)jarg1;
17536   arg2 = (Dali::Vector2 *)jarg2;
17537   if (!arg2) {
17538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17539     return 0;
17540   }
17541   {
17542     try {
17543       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17544     } catch (std::out_of_range& e) {
17545       {
17546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (std::exception& e) {
17549       {
17550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (Dali::DaliException e) {
17553       {
17554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17555       };
17556     } catch (...) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17559       };
17560     }
17561   }
17562
17563   jresult = result;
17564   return jresult;
17565 }
17566
17567
17568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17569   unsigned int jresult ;
17570   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17571   Dali::Vector3 *arg2 = 0 ;
17572   bool result;
17573
17574   arg1 = (Dali::Property::Value *)jarg1;
17575   arg2 = (Dali::Vector3 *)jarg2;
17576   if (!arg2) {
17577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17578     return 0;
17579   }
17580   {
17581     try {
17582       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17583     } catch (std::out_of_range& e) {
17584       {
17585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17586       };
17587     } catch (std::exception& e) {
17588       {
17589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (Dali::DaliException e) {
17592       {
17593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17594       };
17595     } catch (...) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17598       };
17599     }
17600   }
17601
17602   jresult = result;
17603   return jresult;
17604 }
17605
17606
17607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17608   unsigned int jresult ;
17609   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17610   Dali::Vector4 *arg2 = 0 ;
17611   bool result;
17612
17613   arg1 = (Dali::Property::Value *)jarg1;
17614   arg2 = (Dali::Vector4 *)jarg2;
17615   if (!arg2) {
17616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17617     return 0;
17618   }
17619   {
17620     try {
17621       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17622     } catch (std::out_of_range& e) {
17623       {
17624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17625       };
17626     } catch (std::exception& e) {
17627       {
17628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (Dali::DaliException e) {
17631       {
17632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17637       };
17638     }
17639   }
17640
17641   jresult = result;
17642   return jresult;
17643 }
17644
17645
17646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17647   unsigned int jresult ;
17648   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17649   Dali::Matrix3 *arg2 = 0 ;
17650   bool result;
17651
17652   arg1 = (Dali::Property::Value *)jarg1;
17653   arg2 = (Dali::Matrix3 *)jarg2;
17654   if (!arg2) {
17655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17656     return 0;
17657   }
17658   {
17659     try {
17660       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (Dali::DaliException e) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17672       };
17673     } catch (...) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17676       };
17677     }
17678   }
17679
17680   jresult = result;
17681   return jresult;
17682 }
17683
17684
17685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17686   unsigned int jresult ;
17687   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17688   Dali::Matrix *arg2 = 0 ;
17689   bool result;
17690
17691   arg1 = (Dali::Property::Value *)jarg1;
17692   arg2 = (Dali::Matrix *)jarg2;
17693   if (!arg2) {
17694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17695     return 0;
17696   }
17697   {
17698     try {
17699       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17700     } catch (std::out_of_range& e) {
17701       {
17702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17703       };
17704     } catch (std::exception& e) {
17705       {
17706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (Dali::DaliException e) {
17709       {
17710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17711       };
17712     } catch (...) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17715       };
17716     }
17717   }
17718
17719   jresult = result;
17720   return jresult;
17721 }
17722
17723
17724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17725   unsigned int jresult ;
17726   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17727   Dali::AngleAxis *arg2 = 0 ;
17728   bool result;
17729
17730   arg1 = (Dali::Property::Value *)jarg1;
17731   arg2 = (Dali::AngleAxis *)jarg2;
17732   if (!arg2) {
17733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17734     return 0;
17735   }
17736   {
17737     try {
17738       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17739     } catch (std::out_of_range& e) {
17740       {
17741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (std::exception& e) {
17744       {
17745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (Dali::DaliException e) {
17748       {
17749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757
17758   jresult = result;
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17764   unsigned int jresult ;
17765   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17766   Dali::Quaternion *arg2 = 0 ;
17767   bool result;
17768
17769   arg1 = (Dali::Property::Value *)jarg1;
17770   arg2 = (Dali::Quaternion *)jarg2;
17771   if (!arg2) {
17772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17773     return 0;
17774   }
17775   {
17776     try {
17777       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17778     } catch (std::out_of_range& e) {
17779       {
17780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17781       };
17782     } catch (std::exception& e) {
17783       {
17784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (Dali::DaliException e) {
17787       {
17788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17789       };
17790     } catch (...) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17793       };
17794     }
17795   }
17796
17797   jresult = result;
17798   return jresult;
17799 }
17800
17801
17802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17803   unsigned int jresult ;
17804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17805   std::string *arg2 = 0 ;
17806   bool result;
17807
17808   arg1 = (Dali::Property::Value *)jarg1;
17809
17810   //typemap in
17811   std::string temp;
17812   arg2 = &temp;
17813
17814   {
17815     try {
17816       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (Dali::DaliException e) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17828       };
17829     } catch (...) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17832       };
17833     }
17834   }
17835
17836   jresult = result;
17837
17838   //Typemap argout in c++ file.
17839   //This will convert c++ string to c# string
17840   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17841
17842   return jresult;
17843 }
17844
17845
17846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17847   unsigned int jresult ;
17848   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17849   Dali::Property::Array *arg2 = 0 ;
17850   bool result;
17851
17852   arg1 = (Dali::Property::Value *)jarg1;
17853   arg2 = (Dali::Property::Array *)jarg2;
17854   if (!arg2) {
17855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17856     return 0;
17857   }
17858   {
17859     try {
17860       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17861     } catch (std::out_of_range& e) {
17862       {
17863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17864       };
17865     } catch (std::exception& e) {
17866       {
17867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (Dali::DaliException e) {
17870       {
17871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17872       };
17873     } catch (...) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17876       };
17877     }
17878   }
17879
17880   jresult = result;
17881   return jresult;
17882 }
17883
17884
17885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17886   unsigned int jresult ;
17887   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17888   Dali::Property::Map *arg2 = 0 ;
17889   bool result;
17890
17891   arg1 = (Dali::Property::Value *)jarg1;
17892   arg2 = (Dali::Property::Map *)jarg2;
17893   if (!arg2) {
17894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17895     return 0;
17896   }
17897   {
17898     try {
17899       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17900     } catch (std::out_of_range& e) {
17901       {
17902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17903       };
17904     } catch (std::exception& e) {
17905       {
17906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (Dali::DaliException e) {
17909       {
17910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17911       };
17912     } catch (...) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17915       };
17916     }
17917   }
17918
17919   jresult = result;
17920   return jresult;
17921 }
17922
17923
17924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17925   unsigned int jresult ;
17926   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17927   Extents *arg2 = 0 ;
17928   bool result;
17929
17930   arg1 = (Dali::Property::Value *)jarg1;
17931   arg2 = (Extents *)jarg2;
17932   if (!arg2) {
17933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17934     return 0;
17935   }
17936   {
17937     try {
17938       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17939     } catch (std::out_of_range& e) {
17940       {
17941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17942       };
17943     } catch (std::exception& e) {
17944       {
17945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (...) {
17948       {
17949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17950       };
17951     }
17952   }
17953   jresult = result;
17954   return jresult;
17955 }
17956
17957
17958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17959   void * jresult ;
17960   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17961   Dali::Property::Array *result = 0 ;
17962
17963   arg1 = (Dali::Property::Value *)jarg1;
17964   {
17965     try {
17966       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (Dali::DaliException e) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17978       };
17979     } catch (...) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17982       };
17983     }
17984   }
17985
17986   jresult = (void *)result;
17987   return jresult;
17988 }
17989
17990
17991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17992   void * jresult ;
17993   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17994   Dali::Property::Map *result = 0 ;
17995
17996   arg1 = (Dali::Property::Value *)jarg1;
17997   {
17998     try {
17999       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18000     } catch (std::out_of_range& e) {
18001       {
18002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (std::exception& e) {
18005       {
18006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (Dali::DaliException e) {
18009       {
18010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18011       };
18012     } catch (...) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18015       };
18016     }
18017   }
18018
18019   jresult = (void *)result;
18020   return jresult;
18021 }
18022
18023
18024 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18025   char * jresult ;
18026   Dali::Property::Type arg1 ;
18027   char *result = 0 ;
18028
18029   arg1 = (Dali::Property::Type)jarg1;
18030   {
18031     try {
18032       result = (char *)Dali::PropertyTypes::GetName(arg1);
18033     } catch (std::out_of_range& e) {
18034       {
18035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18036       };
18037     } catch (std::exception& e) {
18038       {
18039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (Dali::DaliException e) {
18042       {
18043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18044       };
18045     } catch (...) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18048       };
18049     }
18050   }
18051
18052   jresult = SWIG_csharp_string_callback((const char *)result);
18053   return jresult;
18054 }
18055
18056
18057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18058   unsigned int jresult ;
18059   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18060   std::string *arg2 = 0 ;
18061   Dali::Property::Map *arg3 = 0 ;
18062   bool result;
18063
18064   arg1 = (Dali::BaseObject *)jarg1;
18065   if (!jarg2) {
18066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18067     return 0;
18068   }
18069   std::string arg2_str(jarg2);
18070   arg2 = &arg2_str;
18071   arg3 = (Dali::Property::Map *)jarg3;
18072   if (!arg3) {
18073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18074     return 0;
18075   }
18076   {
18077     try {
18078       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18079     } catch (std::out_of_range& e) {
18080       {
18081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18082       };
18083     } catch (std::exception& e) {
18084       {
18085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (Dali::DaliException e) {
18088       {
18089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18090       };
18091     } catch (...) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18094       };
18095     }
18096   }
18097
18098   jresult = result;
18099
18100   //argout typemap for const std::string&
18101
18102   return jresult;
18103 }
18104
18105
18106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18107   char * jresult ;
18108   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18109   std::string *result = 0 ;
18110
18111   arg1 = (Dali::BaseObject *)jarg1;
18112   {
18113     try {
18114       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18115     } catch (std::out_of_range& e) {
18116       {
18117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (std::exception& e) {
18120       {
18121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (Dali::DaliException e) {
18124       {
18125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18126       };
18127     } catch (...) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18130       };
18131     }
18132   }
18133
18134   jresult = SWIG_csharp_string_callback(result->c_str());
18135   return jresult;
18136 }
18137
18138
18139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18140   unsigned int jresult ;
18141   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18142   Dali::TypeInfo *arg2 = 0 ;
18143   bool result;
18144
18145   arg1 = (Dali::BaseObject *)jarg1;
18146   arg2 = (Dali::TypeInfo *)jarg2;
18147   if (!arg2) {
18148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18149     return 0;
18150   }
18151   {
18152     try {
18153       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18154     } catch (std::out_of_range& e) {
18155       {
18156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18157       };
18158     } catch (std::exception& e) {
18159       {
18160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (Dali::DaliException e) {
18163       {
18164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18165       };
18166     } catch (...) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18169       };
18170     }
18171   }
18172
18173   jresult = result;
18174   return jresult;
18175 }
18176
18177
18178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18179   unsigned int jresult ;
18180   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18181   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18182   std::string *arg3 = 0 ;
18183   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18184   bool result;
18185
18186   arg1 = (Dali::BaseObject *)jarg1;
18187   arg2 = (ConnectionTrackerInterface *)jarg2;
18188   if (!jarg3) {
18189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18190     return 0;
18191   }
18192   std::string arg3_str(jarg3);
18193   arg3 = &arg3_str;
18194   arg4 = (FunctorDelegate *)jarg4;
18195   {
18196     try {
18197       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18198     } catch (std::out_of_range& e) {
18199       {
18200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18201       };
18202     } catch (std::exception& e) {
18203       {
18204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (Dali::DaliException e) {
18207       {
18208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18209       };
18210     } catch (...) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18213       };
18214     }
18215   }
18216
18217   jresult = result;
18218
18219   //argout typemap for const std::string&
18220
18221   return jresult;
18222 }
18223
18224
18225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18226   void * jresult ;
18227   Dali::BaseHandle *arg1 = 0 ;
18228   Dali::BaseObject *result = 0 ;
18229
18230   arg1 = (Dali::BaseHandle *)jarg1;
18231   if (!arg1) {
18232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18233     return 0;
18234   }
18235   {
18236     try {
18237       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18238     } catch (std::out_of_range& e) {
18239       {
18240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18241       };
18242     } catch (std::exception& e) {
18243       {
18244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (Dali::DaliException e) {
18247       {
18248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18249       };
18250     } catch (...) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18253       };
18254     }
18255   }
18256
18257   jresult = (void *)result;
18258   return jresult;
18259 }
18260
18261
18262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18263   void * jresult ;
18264   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18265   Dali::BaseHandle *result = 0 ;
18266
18267   arg1 = (Dali::BaseObject *)jarg1;
18268   {
18269     try {
18270       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18271     } catch (std::out_of_range& e) {
18272       {
18273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18274       };
18275     } catch (std::exception& e) {
18276       {
18277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (Dali::DaliException e) {
18280       {
18281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18282       };
18283     } catch (...) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18286       };
18287     }
18288   }
18289
18290   jresult = (void *)result;
18291   return jresult;
18292 }
18293
18294
18295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18296   void * jresult ;
18297   Dali::BaseHandle *result = 0 ;
18298
18299   {
18300     try {
18301       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18302     } catch (std::out_of_range& e) {
18303       {
18304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18305       };
18306     } catch (std::exception& e) {
18307       {
18308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (Dali::DaliException e) {
18311       {
18312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18313       };
18314     } catch (...) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18317       };
18318     }
18319   }
18320
18321   jresult = (void *)result;
18322   return jresult;
18323 }
18324
18325
18326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18327   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18328
18329   arg1 = (Dali::BaseHandle *)jarg1;
18330   {
18331     try {
18332       delete arg1;
18333     } catch (std::out_of_range& e) {
18334       {
18335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18336       };
18337     } catch (std::exception& e) {
18338       {
18339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (Dali::DaliException e) {
18342       {
18343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18344       };
18345     } catch (...) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18348       };
18349     }
18350   }
18351
18352 }
18353
18354
18355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18356   void * jresult ;
18357   Dali::BaseHandle *arg1 = 0 ;
18358   Dali::BaseHandle *result = 0 ;
18359
18360   arg1 = (Dali::BaseHandle *)jarg1;
18361   if (!arg1) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18363     return 0;
18364   }
18365   {
18366     try {
18367       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18368     } catch (std::out_of_range& e) {
18369       {
18370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18371       };
18372     } catch (std::exception& e) {
18373       {
18374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (Dali::DaliException e) {
18377       {
18378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18379       };
18380     } catch (...) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18383       };
18384     }
18385   }
18386
18387   jresult = (void *)result;
18388   return jresult;
18389 }
18390
18391
18392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18393   void * jresult ;
18394   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18395   Dali::BaseHandle *arg2 = 0 ;
18396   Dali::BaseHandle *result = 0 ;
18397
18398   arg1 = (Dali::BaseHandle *)jarg1;
18399   arg2 = (Dali::BaseHandle *)jarg2;
18400   if (!arg2) {
18401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18402     return 0;
18403   }
18404   {
18405     try {
18406       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18407     } catch (std::out_of_range& e) {
18408       {
18409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18410       };
18411     } catch (std::exception& e) {
18412       {
18413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (Dali::DaliException e) {
18416       {
18417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18418       };
18419     } catch (...) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18422       };
18423     }
18424   }
18425
18426   jresult = (void *)result;
18427   return jresult;
18428 }
18429
18430
18431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18432   unsigned int jresult ;
18433   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18434   std::string *arg2 = 0 ;
18435   Dali::Property::Map *arg3 = 0 ;
18436   bool result;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   if (!jarg2) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18441     return 0;
18442   }
18443   std::string arg2_str(jarg2);
18444   arg2 = &arg2_str;
18445   arg3 = (Dali::Property::Map *)jarg3;
18446   if (!arg3) {
18447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18448     return 0;
18449   }
18450   {
18451     try {
18452       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18453     } catch (std::out_of_range& e) {
18454       {
18455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18456       };
18457     } catch (std::exception& e) {
18458       {
18459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (Dali::DaliException e) {
18462       {
18463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18464       };
18465     } catch (...) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18468       };
18469     }
18470   }
18471
18472   jresult = result;
18473
18474   //argout typemap for const std::string&
18475
18476   return jresult;
18477 }
18478
18479
18480 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18481   char * jresult ;
18482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18483   std::string *result = 0 ;
18484
18485   arg1 = (Dali::BaseHandle *)jarg1;
18486   {
18487     try {
18488       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18489     } catch (std::out_of_range& e) {
18490       {
18491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18492       };
18493     } catch (std::exception& e) {
18494       {
18495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (Dali::DaliException e) {
18498       {
18499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18500       };
18501     } catch (...) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18504       };
18505     }
18506   }
18507
18508   jresult = SWIG_csharp_string_callback(result->c_str());
18509   return jresult;
18510 }
18511
18512
18513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18514   unsigned int jresult ;
18515   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18516   Dali::TypeInfo *arg2 = 0 ;
18517   bool result;
18518
18519   arg1 = (Dali::BaseHandle *)jarg1;
18520   arg2 = (Dali::TypeInfo *)jarg2;
18521   if (!arg2) {
18522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18523     return 0;
18524   }
18525   {
18526     try {
18527       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (Dali::DaliException e) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18539       };
18540     } catch (...) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18543       };
18544     }
18545   }
18546
18547   jresult = result;
18548   return jresult;
18549 }
18550
18551
18552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18553   void * jresult ;
18554   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18555   Dali::BaseObject *result = 0 ;
18556
18557   arg1 = (Dali::BaseHandle *)jarg1;
18558   {
18559     try {
18560       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18561     } catch (std::out_of_range& e) {
18562       {
18563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18564       };
18565     } catch (std::exception& e) {
18566       {
18567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (Dali::DaliException e) {
18570       {
18571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18572       };
18573     } catch (...) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18576       };
18577     }
18578   }
18579
18580   jresult = (void *)result;
18581   return jresult;
18582 }
18583
18584
18585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18586   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18587
18588   arg1 = (Dali::BaseHandle *)jarg1;
18589   {
18590     try {
18591       (arg1)->Reset();
18592     } catch (std::out_of_range& e) {
18593       {
18594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18595       };
18596     } catch (std::exception& e) {
18597       {
18598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (Dali::DaliException e) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18603       };
18604     } catch (...) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18607       };
18608     }
18609   }
18610
18611 }
18612
18613
18614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18615   unsigned int jresult ;
18616   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18617   Dali::BaseHandle *arg2 = 0 ;
18618   bool result;
18619
18620   arg1 = (Dali::BaseHandle *)jarg1;
18621   arg2 = (Dali::BaseHandle *)jarg2;
18622   if (!arg2) {
18623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18624     return 0;
18625   }
18626   {
18627     try {
18628       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18629     } catch (std::out_of_range& e) {
18630       {
18631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18632       };
18633     } catch (std::exception& e) {
18634       {
18635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (Dali::DaliException e) {
18638       {
18639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18640       };
18641     } catch (...) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18644       };
18645     }
18646   }
18647
18648   jresult = result;
18649   return jresult;
18650 }
18651
18652
18653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18654   unsigned int jresult ;
18655   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18656   Dali::BaseHandle *arg2 = 0 ;
18657   bool result;
18658
18659   arg1 = (Dali::BaseHandle *)jarg1;
18660   arg2 = (Dali::BaseHandle *)jarg2;
18661   if (!arg2) {
18662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18663     return 0;
18664   }
18665   {
18666     try {
18667       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18668     } catch (std::out_of_range& e) {
18669       {
18670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18671       };
18672     } catch (std::exception& e) {
18673       {
18674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (Dali::DaliException e) {
18677       {
18678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18679       };
18680     } catch (...) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18683       };
18684     }
18685   }
18686
18687   jresult = result;
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18693   void * jresult ;
18694   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18695   Dali::RefObject *result = 0 ;
18696
18697   arg1 = (Dali::BaseHandle *)jarg1;
18698   {
18699     try {
18700       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18701     } catch (std::out_of_range& e) {
18702       {
18703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18704       };
18705     } catch (std::exception& e) {
18706       {
18707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (Dali::DaliException e) {
18710       {
18711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18712       };
18713     } catch (...) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18716       };
18717     }
18718   }
18719
18720   jresult = (void *)result;
18721   return jresult;
18722 }
18723
18724
18725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18726   unsigned int jresult ;
18727   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18728   bool result;
18729
18730   arg1 = (Dali::BaseHandle *)jarg1;
18731   {
18732     try {
18733       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18734     } catch (std::out_of_range& e) {
18735       {
18736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18737       };
18738     } catch (std::exception& e) {
18739       {
18740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (Dali::DaliException e) {
18743       {
18744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18745       };
18746     } catch (...) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18749       };
18750     }
18751   }
18752
18753   jresult = result;
18754   return jresult;
18755 }
18756
18757
18758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18759   unsigned int jresult ;
18760   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18761   Dali::BaseHandle *arg2 = 0 ;
18762   bool result;
18763
18764   arg1 = (Dali::BaseHandle *)jarg1;
18765   arg2 = (Dali::BaseHandle *)jarg2;
18766   if (!arg2) {
18767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18768     return 0;
18769   }
18770   {
18771     try {
18772       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18773     } catch (std::out_of_range& e) {
18774       {
18775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (std::exception& e) {
18778       {
18779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (Dali::DaliException e) {
18782       {
18783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18784       };
18785     } catch (...) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18788       };
18789     }
18790   }
18791
18792   jresult = result;
18793   return jresult;
18794 }
18795
18796
18797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18798   unsigned int jresult ;
18799   Dali::BaseHandle *arg1 = 0 ;
18800   Dali::BaseHandle *arg2 = 0 ;
18801   bool result;
18802
18803   arg1 = (Dali::BaseHandle *)jarg1;
18804   if (!arg1) {
18805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18806     return 0;
18807   }
18808   arg2 = (Dali::BaseHandle *)jarg2;
18809   if (!arg2) {
18810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18811     return 0;
18812   }
18813   {
18814     try {
18815       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18816     } catch (std::out_of_range& e) {
18817       {
18818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (std::exception& e) {
18821       {
18822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (Dali::DaliException e) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18827       };
18828     } catch (...) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18831       };
18832     }
18833   }
18834
18835   jresult = result;
18836   return jresult;
18837 }
18838
18839
18840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18841   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18842
18843   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18844   {
18845     try {
18846       delete arg1;
18847     } catch (std::out_of_range& e) {
18848       {
18849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18850       };
18851     } catch (std::exception& e) {
18852       {
18853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (Dali::DaliException e) {
18856       {
18857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18858       };
18859     } catch (...) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18862       };
18863     }
18864   }
18865
18866 }
18867
18868
18869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18870   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18871   SlotObserver *arg2 = (SlotObserver *) 0 ;
18872   CallbackBase *arg3 = (CallbackBase *) 0 ;
18873
18874   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18875   arg2 = (SlotObserver *)jarg2;
18876   arg3 = (CallbackBase *)jarg3;
18877   {
18878     try {
18879       (arg1)->SignalConnected(arg2,arg3);
18880     } catch (std::out_of_range& e) {
18881       {
18882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18883       };
18884     } catch (std::exception& e) {
18885       {
18886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (Dali::DaliException e) {
18889       {
18890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18891       };
18892     } catch (...) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18895       };
18896     }
18897   }
18898
18899 }
18900
18901
18902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18903   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18904
18905   arg1 = (Dali::SignalObserver *)jarg1;
18906   {
18907     try {
18908       delete arg1;
18909     } catch (std::out_of_range& e) {
18910       {
18911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18912       };
18913     } catch (std::exception& e) {
18914       {
18915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (Dali::DaliException e) {
18918       {
18919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18920       };
18921     } catch (...) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18924       };
18925     }
18926   }
18927
18928 }
18929
18930
18931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18932   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18933   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18934   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18935
18936   arg1 = (Dali::SignalObserver *)jarg1;
18937   arg2 = (Dali::SlotObserver *)jarg2;
18938   arg3 = (Dali::CallbackBase *)jarg3;
18939   {
18940     try {
18941       (arg1)->SignalDisconnected(arg2,arg3);
18942     } catch (std::out_of_range& e) {
18943       {
18944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18945       };
18946     } catch (std::exception& e) {
18947       {
18948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (Dali::DaliException e) {
18951       {
18952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18953       };
18954     } catch (...) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18957       };
18958     }
18959   }
18960
18961 }
18962
18963
18964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18965   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18966
18967   arg1 = (Dali::SlotObserver *)jarg1;
18968   {
18969     try {
18970       delete arg1;
18971     } catch (std::out_of_range& e) {
18972       {
18973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18974       };
18975     } catch (std::exception& e) {
18976       {
18977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (Dali::DaliException e) {
18980       {
18981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18982       };
18983     } catch (...) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18986       };
18987     }
18988   }
18989
18990 }
18991
18992
18993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18994   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18995   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18996
18997   arg1 = (Dali::SlotObserver *)jarg1;
18998   arg2 = (Dali::CallbackBase *)jarg2;
18999   {
19000     try {
19001       (arg1)->SlotDisconnected(arg2);
19002     } catch (std::out_of_range& e) {
19003       {
19004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19005       };
19006     } catch (std::exception& e) {
19007       {
19008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (Dali::DaliException e) {
19011       {
19012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19013       };
19014     } catch (...) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19017       };
19018     }
19019   }
19020
19021 }
19022
19023
19024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19025   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19026
19027   arg1 = (Dali::ConnectionTracker *)jarg1;
19028   {
19029     try {
19030       delete arg1;
19031     } catch (std::out_of_range& e) {
19032       {
19033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19034       };
19035     } catch (std::exception& e) {
19036       {
19037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (Dali::DaliException e) {
19040       {
19041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19042       };
19043     } catch (...) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19046       };
19047     }
19048   }
19049
19050 }
19051
19052
19053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19054   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19055
19056   arg1 = (Dali::ConnectionTracker *)jarg1;
19057   {
19058     try {
19059       (arg1)->DisconnectAll();
19060     } catch (std::out_of_range& e) {
19061       {
19062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19063       };
19064     } catch (std::exception& e) {
19065       {
19066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (Dali::DaliException e) {
19069       {
19070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19071       };
19072     } catch (...) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19075       };
19076     }
19077   }
19078
19079 }
19080
19081
19082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19083   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19084   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19085   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19086
19087   arg1 = (Dali::ConnectionTracker *)jarg1;
19088   arg2 = (Dali::SlotObserver *)jarg2;
19089   arg3 = (Dali::CallbackBase *)jarg3;
19090   {
19091     try {
19092       (arg1)->SignalConnected(arg2,arg3);
19093     } catch (std::out_of_range& e) {
19094       {
19095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19096       };
19097     } catch (std::exception& e) {
19098       {
19099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (Dali::DaliException e) {
19102       {
19103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19104       };
19105     } catch (...) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19108       };
19109     }
19110   }
19111
19112 }
19113
19114
19115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19116   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19117   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19118   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19119
19120   arg1 = (Dali::ConnectionTracker *)jarg1;
19121   arg2 = (Dali::SlotObserver *)jarg2;
19122   arg3 = (Dali::CallbackBase *)jarg3;
19123   {
19124     try {
19125       (arg1)->SignalDisconnected(arg2,arg3);
19126     } catch (std::out_of_range& e) {
19127       {
19128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19129       };
19130     } catch (std::exception& e) {
19131       {
19132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (Dali::DaliException e) {
19135       {
19136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19137       };
19138     } catch (...) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19141       };
19142     }
19143   }
19144
19145 }
19146
19147
19148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19149   unsigned long jresult ;
19150   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19151   std::size_t result;
19152
19153   arg1 = (Dali::ConnectionTracker *)jarg1;
19154   {
19155     try {
19156       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19157     } catch (std::out_of_range& e) {
19158       {
19159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19160       };
19161     } catch (std::exception& e) {
19162       {
19163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (Dali::DaliException e) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19168       };
19169     } catch (...) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19172       };
19173     }
19174   }
19175
19176   jresult = (unsigned long)result;
19177   return jresult;
19178 }
19179
19180
19181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19182   void * jresult ;
19183   Dali::ObjectRegistry *result = 0 ;
19184
19185   {
19186     try {
19187       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19188     } catch (std::out_of_range& e) {
19189       {
19190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19191       };
19192     } catch (std::exception& e) {
19193       {
19194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (Dali::DaliException e) {
19197       {
19198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19199       };
19200     } catch (...) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19203       };
19204     }
19205   }
19206
19207   jresult = (void *)result;
19208   return jresult;
19209 }
19210
19211
19212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19213   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19214
19215   arg1 = (Dali::ObjectRegistry *)jarg1;
19216   {
19217     try {
19218       delete arg1;
19219     } catch (std::out_of_range& e) {
19220       {
19221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19222       };
19223     } catch (std::exception& e) {
19224       {
19225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (Dali::DaliException e) {
19228       {
19229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19230       };
19231     } catch (...) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19234       };
19235     }
19236   }
19237
19238 }
19239
19240
19241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19242   void * jresult ;
19243   Dali::ObjectRegistry *arg1 = 0 ;
19244   Dali::ObjectRegistry *result = 0 ;
19245
19246   arg1 = (Dali::ObjectRegistry *)jarg1;
19247   if (!arg1) {
19248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19249     return 0;
19250   }
19251   {
19252     try {
19253       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19254     } catch (std::out_of_range& e) {
19255       {
19256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (std::exception& e) {
19259       {
19260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (Dali::DaliException e) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19265       };
19266     } catch (...) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19269       };
19270     }
19271   }
19272
19273   jresult = (void *)result;
19274   return jresult;
19275 }
19276
19277
19278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19279   void * jresult ;
19280   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19281   Dali::ObjectRegistry *arg2 = 0 ;
19282   Dali::ObjectRegistry *result = 0 ;
19283
19284   arg1 = (Dali::ObjectRegistry *)jarg1;
19285   arg2 = (Dali::ObjectRegistry *)jarg2;
19286   if (!arg2) {
19287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19288     return 0;
19289   }
19290   {
19291     try {
19292       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19293     } catch (std::out_of_range& e) {
19294       {
19295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19296       };
19297     } catch (std::exception& e) {
19298       {
19299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (Dali::DaliException e) {
19302       {
19303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19304       };
19305     } catch (...) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19308       };
19309     }
19310   }
19311
19312   jresult = (void *)result;
19313   return jresult;
19314 }
19315
19316
19317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19318   void * jresult ;
19319   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19320   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19321
19322   arg1 = (Dali::ObjectRegistry *)jarg1;
19323   {
19324     try {
19325       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19326     } catch (std::out_of_range& e) {
19327       {
19328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19329       };
19330     } catch (std::exception& e) {
19331       {
19332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (Dali::DaliException e) {
19335       {
19336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19337       };
19338     } catch (...) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19341       };
19342     }
19343   }
19344
19345   jresult = (void *)result;
19346   return jresult;
19347 }
19348
19349
19350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19351   void * jresult ;
19352   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19353   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19354
19355   arg1 = (Dali::ObjectRegistry *)jarg1;
19356   {
19357     try {
19358       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19359     } catch (std::out_of_range& e) {
19360       {
19361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (std::exception& e) {
19364       {
19365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (Dali::DaliException e) {
19368       {
19369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19370       };
19371     } catch (...) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19374       };
19375     }
19376   }
19377
19378   jresult = (void *)result;
19379   return jresult;
19380 }
19381
19382
19383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19384   void * jresult ;
19385   Dali::PropertyCondition *result = 0 ;
19386
19387   {
19388     try {
19389       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19390     } catch (std::out_of_range& e) {
19391       {
19392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (std::exception& e) {
19395       {
19396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (Dali::DaliException e) {
19399       {
19400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19401       };
19402     } catch (...) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19405       };
19406     }
19407   }
19408
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19415   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19416
19417   arg1 = (Dali::PropertyCondition *)jarg1;
19418   {
19419     try {
19420       delete arg1;
19421     } catch (std::out_of_range& e) {
19422       {
19423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19424       };
19425     } catch (std::exception& e) {
19426       {
19427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (Dali::DaliException e) {
19430       {
19431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19432       };
19433     } catch (...) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19436       };
19437     }
19438   }
19439
19440 }
19441
19442
19443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19444   void * jresult ;
19445   Dali::PropertyCondition *arg1 = 0 ;
19446   Dali::PropertyCondition *result = 0 ;
19447
19448   arg1 = (Dali::PropertyCondition *)jarg1;
19449   if (!arg1) {
19450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19451     return 0;
19452   }
19453   {
19454     try {
19455       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19456     } catch (std::out_of_range& e) {
19457       {
19458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19459       };
19460     } catch (std::exception& e) {
19461       {
19462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (Dali::DaliException e) {
19465       {
19466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19467       };
19468     } catch (...) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19471       };
19472     }
19473   }
19474
19475   jresult = (void *)result;
19476   return jresult;
19477 }
19478
19479
19480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19481   void * jresult ;
19482   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19483   Dali::PropertyCondition *arg2 = 0 ;
19484   Dali::PropertyCondition *result = 0 ;
19485
19486   arg1 = (Dali::PropertyCondition *)jarg1;
19487   arg2 = (Dali::PropertyCondition *)jarg2;
19488   if (!arg2) {
19489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19490     return 0;
19491   }
19492   {
19493     try {
19494       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19495     } catch (std::out_of_range& e) {
19496       {
19497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19498       };
19499     } catch (std::exception& e) {
19500       {
19501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (Dali::DaliException e) {
19504       {
19505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19506       };
19507     } catch (...) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19510       };
19511     }
19512   }
19513
19514   jresult = (void *)result;
19515   return jresult;
19516 }
19517
19518
19519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19520   unsigned long jresult ;
19521   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19522   std::size_t result;
19523
19524   arg1 = (Dali::PropertyCondition *)jarg1;
19525   {
19526     try {
19527       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19528     } catch (std::out_of_range& e) {
19529       {
19530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19531       };
19532     } catch (std::exception& e) {
19533       {
19534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (...) {
19537       {
19538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19539       };
19540     }
19541   }
19542   jresult = (unsigned long)result;
19543   return jresult;
19544 }
19545
19546
19547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19548   float jresult ;
19549   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19550   std::size_t arg2 ;
19551   float result;
19552
19553   arg1 = (Dali::PropertyCondition *)jarg1;
19554   arg2 = (std::size_t)jarg2;
19555   {
19556     try {
19557       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19558     } catch (std::out_of_range& e) {
19559       {
19560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19561       };
19562     } catch (std::exception& e) {
19563       {
19564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (...) {
19567       {
19568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19569       };
19570     }
19571   }
19572   jresult = result;
19573   return jresult;
19574 }
19575
19576
19577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19578   void * jresult ;
19579   float arg1 ;
19580   Dali::PropertyCondition result;
19581
19582   arg1 = (float)jarg1;
19583   {
19584     try {
19585       result = Dali::LessThanCondition(arg1);
19586     } catch (std::out_of_range& e) {
19587       {
19588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (std::exception& e) {
19591       {
19592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (Dali::DaliException e) {
19595       {
19596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19597       };
19598     } catch (...) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19601       };
19602     }
19603   }
19604
19605   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19606   return jresult;
19607 }
19608
19609
19610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19611   void * jresult ;
19612   float arg1 ;
19613   Dali::PropertyCondition result;
19614
19615   arg1 = (float)jarg1;
19616   {
19617     try {
19618       result = Dali::GreaterThanCondition(arg1);
19619     } catch (std::out_of_range& e) {
19620       {
19621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (std::exception& e) {
19624       {
19625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (Dali::DaliException e) {
19628       {
19629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19630       };
19631     } catch (...) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19634       };
19635     }
19636   }
19637
19638   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19639   return jresult;
19640 }
19641
19642
19643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19644   void * jresult ;
19645   float arg1 ;
19646   float arg2 ;
19647   Dali::PropertyCondition result;
19648
19649   arg1 = (float)jarg1;
19650   arg2 = (float)jarg2;
19651   {
19652     try {
19653       result = Dali::InsideCondition(arg1,arg2);
19654     } catch (std::out_of_range& e) {
19655       {
19656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19657       };
19658     } catch (std::exception& e) {
19659       {
19660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (Dali::DaliException e) {
19663       {
19664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19665       };
19666     } catch (...) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19669       };
19670     }
19671   }
19672
19673   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19674   return jresult;
19675 }
19676
19677
19678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19679   void * jresult ;
19680   float arg1 ;
19681   float arg2 ;
19682   Dali::PropertyCondition result;
19683
19684   arg1 = (float)jarg1;
19685   arg2 = (float)jarg2;
19686   {
19687     try {
19688       result = Dali::OutsideCondition(arg1,arg2);
19689     } catch (std::out_of_range& e) {
19690       {
19691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19692       };
19693     } catch (std::exception& e) {
19694       {
19695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (Dali::DaliException e) {
19698       {
19699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19700       };
19701     } catch (...) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19704       };
19705     }
19706   }
19707
19708   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19709   return jresult;
19710 }
19711
19712
19713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19714   void * jresult ;
19715   float arg1 ;
19716   float arg2 ;
19717   Dali::PropertyCondition result;
19718
19719   arg1 = (float)jarg1;
19720   arg2 = (float)jarg2;
19721   {
19722     try {
19723       result = Dali::StepCondition(arg1,arg2);
19724     } catch (std::out_of_range& e) {
19725       {
19726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19727       };
19728     } catch (std::exception& e) {
19729       {
19730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (Dali::DaliException e) {
19733       {
19734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19735       };
19736     } catch (...) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19739       };
19740     }
19741   }
19742
19743   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19744   return jresult;
19745 }
19746
19747
19748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19749   void * jresult ;
19750   float arg1 ;
19751   Dali::PropertyCondition result;
19752
19753   arg1 = (float)jarg1;
19754   {
19755     try {
19756       result = Dali::StepCondition(arg1);
19757     } catch (std::out_of_range& e) {
19758       {
19759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19760       };
19761     } catch (std::exception& e) {
19762       {
19763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (Dali::DaliException e) {
19766       {
19767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19768       };
19769     } catch (...) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19772       };
19773     }
19774   }
19775
19776   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19777   return jresult;
19778 }
19779
19780
19781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19782   void * jresult ;
19783   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19784   Dali::PropertyCondition result;
19785
19786   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19787   if (!arg1) {
19788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19789     return 0;
19790   }
19791   {
19792     try {
19793       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19794     } catch (std::out_of_range& e) {
19795       {
19796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19797       };
19798     } catch (std::exception& e) {
19799       {
19800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (Dali::DaliException e) {
19803       {
19804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19805       };
19806     } catch (...) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19809       };
19810     }
19811   }
19812
19813   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19814   return jresult;
19815 }
19816
19817
19818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19819   void * jresult ;
19820   Dali::PropertyNotification *result = 0 ;
19821
19822   {
19823     try {
19824       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19825     } catch (std::out_of_range& e) {
19826       {
19827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19828       };
19829     } catch (std::exception& e) {
19830       {
19831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (Dali::DaliException e) {
19834       {
19835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19836       };
19837     } catch (...) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19840       };
19841     }
19842   }
19843
19844   jresult = (void *)result;
19845   return jresult;
19846 }
19847
19848
19849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19850   void * jresult ;
19851   Dali::BaseHandle arg1 ;
19852   Dali::BaseHandle *argp1 ;
19853   Dali::PropertyNotification result;
19854
19855   argp1 = (Dali::BaseHandle *)jarg1;
19856   if (!argp1) {
19857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19858     return 0;
19859   }
19860   arg1 = *argp1;
19861   {
19862     try {
19863       result = Dali::PropertyNotification::DownCast(arg1);
19864     } catch (std::out_of_range& e) {
19865       {
19866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19867       };
19868     } catch (std::exception& e) {
19869       {
19870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (Dali::DaliException e) {
19873       {
19874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19875       };
19876     } catch (...) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19879       };
19880     }
19881   }
19882
19883   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19884   return jresult;
19885 }
19886
19887
19888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19889   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19890
19891   arg1 = (Dali::PropertyNotification *)jarg1;
19892   {
19893     try {
19894       delete arg1;
19895     } catch (std::out_of_range& e) {
19896       {
19897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19898       };
19899     } catch (std::exception& e) {
19900       {
19901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (Dali::DaliException e) {
19904       {
19905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19906       };
19907     } catch (...) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19910       };
19911     }
19912   }
19913
19914 }
19915
19916
19917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19918   void * jresult ;
19919   Dali::PropertyNotification *arg1 = 0 ;
19920   Dali::PropertyNotification *result = 0 ;
19921
19922   arg1 = (Dali::PropertyNotification *)jarg1;
19923   if (!arg1) {
19924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19925     return 0;
19926   }
19927   {
19928     try {
19929       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19930     } catch (std::out_of_range& e) {
19931       {
19932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19933       };
19934     } catch (std::exception& e) {
19935       {
19936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (Dali::DaliException e) {
19939       {
19940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19941       };
19942     } catch (...) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19945       };
19946     }
19947   }
19948
19949   jresult = (void *)result;
19950   return jresult;
19951 }
19952
19953
19954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19955   void * jresult ;
19956   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19957   Dali::PropertyNotification *arg2 = 0 ;
19958   Dali::PropertyNotification *result = 0 ;
19959
19960   arg1 = (Dali::PropertyNotification *)jarg1;
19961   arg2 = (Dali::PropertyNotification *)jarg2;
19962   if (!arg2) {
19963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19964     return 0;
19965   }
19966   {
19967     try {
19968       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19969     } catch (std::out_of_range& e) {
19970       {
19971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19972       };
19973     } catch (std::exception& e) {
19974       {
19975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (Dali::DaliException e) {
19978       {
19979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19980       };
19981     } catch (...) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19984       };
19985     }
19986   }
19987
19988   jresult = (void *)result;
19989   return jresult;
19990 }
19991
19992
19993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19994   void * jresult ;
19995   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19996   Dali::PropertyCondition result;
19997
19998   arg1 = (Dali::PropertyNotification *)jarg1;
19999   {
20000     try {
20001       result = (arg1)->GetCondition();
20002     } catch (std::out_of_range& e) {
20003       {
20004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (std::exception& e) {
20007       {
20008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (Dali::DaliException e) {
20011       {
20012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20013       };
20014     } catch (...) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20017       };
20018     }
20019   }
20020
20021   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20022   return jresult;
20023 }
20024
20025
20026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20027   void * jresult ;
20028   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20029   Dali::Handle result;
20030
20031   arg1 = (Dali::PropertyNotification *)jarg1;
20032   {
20033     try {
20034       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20035     } catch (std::out_of_range& e) {
20036       {
20037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20038       };
20039     } catch (std::exception& e) {
20040       {
20041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (Dali::DaliException e) {
20044       {
20045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20046       };
20047     } catch (...) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20050       };
20051     }
20052   }
20053
20054   jresult = new Dali::Handle((const Dali::Handle &)result);
20055   return jresult;
20056 }
20057
20058
20059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20060   int jresult ;
20061   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20062   Dali::Property::Index result;
20063
20064   arg1 = (Dali::PropertyNotification *)jarg1;
20065   {
20066     try {
20067       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20068     } catch (std::out_of_range& e) {
20069       {
20070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20071       };
20072     } catch (std::exception& e) {
20073       {
20074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (Dali::DaliException e) {
20077       {
20078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20079       };
20080     } catch (...) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20083       };
20084     }
20085   }
20086
20087   jresult = result;
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20093   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20094   Dali::PropertyNotification::NotifyMode arg2 ;
20095
20096   arg1 = (Dali::PropertyNotification *)jarg1;
20097   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20098   {
20099     try {
20100       (arg1)->SetNotifyMode(arg2);
20101     } catch (std::out_of_range& e) {
20102       {
20103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20104       };
20105     } catch (std::exception& e) {
20106       {
20107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (Dali::DaliException e) {
20110       {
20111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20112       };
20113     } catch (...) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20116       };
20117     }
20118   }
20119
20120 }
20121
20122
20123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20124   int jresult ;
20125   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20126   Dali::PropertyNotification::NotifyMode result;
20127
20128   arg1 = (Dali::PropertyNotification *)jarg1;
20129   {
20130     try {
20131       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20132     } catch (std::out_of_range& e) {
20133       {
20134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20135       };
20136     } catch (std::exception& e) {
20137       {
20138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (Dali::DaliException e) {
20141       {
20142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20143       };
20144     } catch (...) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20147       };
20148     }
20149   }
20150
20151   jresult = (int)result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20157   unsigned int jresult ;
20158   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20159   bool result;
20160
20161   arg1 = (Dali::PropertyNotification *)jarg1;
20162   {
20163     try {
20164       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20165     } catch (std::out_of_range& e) {
20166       {
20167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20168       };
20169     } catch (std::exception& e) {
20170       {
20171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (Dali::DaliException e) {
20174       {
20175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20176       };
20177     } catch (...) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20180       };
20181     }
20182   }
20183
20184   jresult = result;
20185   return jresult;
20186 }
20187
20188
20189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20190   void * jresult ;
20191   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20192   Dali::PropertyNotifySignalType *result = 0 ;
20193
20194   arg1 = (Dali::PropertyNotification *)jarg1;
20195   {
20196     try {
20197       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20198     } catch (std::out_of_range& e) {
20199       {
20200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20201       };
20202     } catch (std::exception& e) {
20203       {
20204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (Dali::DaliException e) {
20207       {
20208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20209       };
20210     } catch (...) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20213       };
20214     }
20215   }
20216
20217   jresult = (void *)result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20223   void * jresult ;
20224   Dali::Handle *result = 0 ;
20225
20226   {
20227     try {
20228       result = (Dali::Handle *)new Dali::Handle();
20229     } catch (std::out_of_range& e) {
20230       {
20231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20232       };
20233     } catch (std::exception& e) {
20234       {
20235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (Dali::DaliException e) {
20238       {
20239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20240       };
20241     } catch (...) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20244       };
20245     }
20246   }
20247
20248   jresult = (void *)result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20254   void * jresult ;
20255   Dali::Handle result;
20256
20257   {
20258     try {
20259       result = Dali::Handle::New();
20260     } catch (std::out_of_range& e) {
20261       {
20262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20263       };
20264     } catch (std::exception& e) {
20265       {
20266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (Dali::DaliException e) {
20269       {
20270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20271       };
20272     } catch (...) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20275       };
20276     }
20277   }
20278
20279   jresult = new Dali::Handle((const Dali::Handle &)result);
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20285   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20286
20287   arg1 = (Dali::Handle *)jarg1;
20288   {
20289     try {
20290       delete arg1;
20291     } catch (std::out_of_range& e) {
20292       {
20293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20294       };
20295     } catch (std::exception& e) {
20296       {
20297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (Dali::DaliException e) {
20300       {
20301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20302       };
20303     } catch (...) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20306       };
20307     }
20308   }
20309
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20314   void * jresult ;
20315   Dali::Handle *arg1 = 0 ;
20316   Dali::Handle *result = 0 ;
20317
20318   arg1 = (Dali::Handle *)jarg1;
20319   if (!arg1) {
20320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20321     return 0;
20322   }
20323   {
20324     try {
20325       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20326     } catch (std::out_of_range& e) {
20327       {
20328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20329       };
20330     } catch (std::exception& e) {
20331       {
20332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (Dali::DaliException e) {
20335       {
20336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20337       };
20338     } catch (...) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20341       };
20342     }
20343   }
20344
20345   jresult = (void *)result;
20346   return jresult;
20347 }
20348
20349
20350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20351   void * jresult ;
20352   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20353   Dali::Handle *arg2 = 0 ;
20354   Dali::Handle *result = 0 ;
20355
20356   arg1 = (Dali::Handle *)jarg1;
20357   arg2 = (Dali::Handle *)jarg2;
20358   if (!arg2) {
20359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20360     return 0;
20361   }
20362   {
20363     try {
20364       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20365     } catch (std::out_of_range& e) {
20366       {
20367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20368       };
20369     } catch (std::exception& e) {
20370       {
20371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (Dali::DaliException e) {
20374       {
20375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20376       };
20377     } catch (...) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20380       };
20381     }
20382   }
20383
20384   jresult = (void *)result;
20385   return jresult;
20386 }
20387
20388
20389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20390   void * jresult ;
20391   Dali::BaseHandle arg1 ;
20392   Dali::BaseHandle *argp1 ;
20393   Dali::Handle result;
20394
20395   argp1 = (Dali::BaseHandle *)jarg1;
20396   if (!argp1) {
20397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20398     return 0;
20399   }
20400   arg1 = *argp1;
20401   {
20402     try {
20403       result = Dali::Handle::DownCast(arg1);
20404     } catch (std::out_of_range& e) {
20405       {
20406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20407       };
20408     } catch (std::exception& e) {
20409       {
20410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (Dali::DaliException e) {
20413       {
20414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20415       };
20416     } catch (...) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20419       };
20420     }
20421   }
20422
20423   jresult = new Dali::Handle((const Dali::Handle &)result);
20424   return jresult;
20425 }
20426
20427
20428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20429   unsigned int jresult ;
20430   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20431   Dali::Handle::Capability arg2 ;
20432   bool result;
20433
20434   arg1 = (Dali::Handle *)jarg1;
20435   arg2 = (Dali::Handle::Capability)jarg2;
20436   {
20437     try {
20438       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20439     } catch (std::out_of_range& e) {
20440       {
20441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20442       };
20443     } catch (std::exception& e) {
20444       {
20445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (Dali::DaliException e) {
20448       {
20449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20450       };
20451     } catch (...) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20454       };
20455     }
20456   }
20457
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20464   unsigned int jresult ;
20465   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20466   unsigned int result;
20467
20468   arg1 = (Dali::Handle *)jarg1;
20469   {
20470     try {
20471       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20472     } catch (std::out_of_range& e) {
20473       {
20474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20475       };
20476     } catch (std::exception& e) {
20477       {
20478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (Dali::DaliException e) {
20481       {
20482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20483       };
20484     } catch (...) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20487       };
20488     }
20489   }
20490
20491   jresult = result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20497   char * jresult ;
20498   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20499   Dali::Property::Index arg2 ;
20500   std::string result;
20501
20502   arg1 = (Dali::Handle *)jarg1;
20503   arg2 = (Dali::Property::Index)jarg2;
20504   {
20505     try {
20506       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20507     } catch (std::out_of_range& e) {
20508       {
20509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20510       };
20511     } catch (std::exception& e) {
20512       {
20513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (Dali::DaliException e) {
20516       {
20517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20518       };
20519     } catch (...) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20522       };
20523     }
20524   }
20525
20526   jresult = SWIG_csharp_string_callback((&result)->c_str());
20527   return jresult;
20528 }
20529
20530
20531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20532   int jresult ;
20533   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20534   std::string *arg2 = 0 ;
20535   Dali::Property::Index result;
20536
20537   arg1 = (Dali::Handle *)jarg1;
20538   if (!jarg2) {
20539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20540     return 0;
20541   }
20542   std::string arg2_str(jarg2);
20543   arg2 = &arg2_str;
20544   {
20545     try {
20546       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20547     } catch (std::out_of_range& e) {
20548       {
20549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20550       };
20551     } catch (std::exception& e) {
20552       {
20553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (Dali::DaliException e) {
20556       {
20557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20558       };
20559     } catch (...) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20562       };
20563     }
20564   }
20565
20566   jresult = result;
20567
20568   //argout typemap for const std::string&
20569
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20575   unsigned int jresult ;
20576   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20577   Dali::Property::Index arg2 ;
20578   bool result;
20579
20580   arg1 = (Dali::Handle *)jarg1;
20581   arg2 = (Dali::Property::Index)jarg2;
20582   {
20583     try {
20584       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20585     } catch (std::out_of_range& e) {
20586       {
20587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20588       };
20589     } catch (std::exception& e) {
20590       {
20591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (Dali::DaliException e) {
20594       {
20595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20596       };
20597     } catch (...) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20600       };
20601     }
20602   }
20603
20604   jresult = result;
20605   return jresult;
20606 }
20607
20608
20609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20610   unsigned int jresult ;
20611   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20612   Dali::Property::Index arg2 ;
20613   bool result;
20614
20615   arg1 = (Dali::Handle *)jarg1;
20616   arg2 = (Dali::Property::Index)jarg2;
20617   {
20618     try {
20619       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20620     } catch (std::out_of_range& e) {
20621       {
20622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20623       };
20624     } catch (std::exception& e) {
20625       {
20626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (Dali::DaliException e) {
20629       {
20630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20631       };
20632     } catch (...) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20635       };
20636     }
20637   }
20638
20639   jresult = result;
20640   return jresult;
20641 }
20642
20643
20644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20645   unsigned int jresult ;
20646   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20647   Dali::Property::Index arg2 ;
20648   bool result;
20649
20650   arg1 = (Dali::Handle *)jarg1;
20651   arg2 = (Dali::Property::Index)jarg2;
20652   {
20653     try {
20654       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20655     } catch (std::out_of_range& e) {
20656       {
20657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20658       };
20659     } catch (std::exception& e) {
20660       {
20661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (Dali::DaliException e) {
20664       {
20665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20666       };
20667     } catch (...) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20670       };
20671     }
20672   }
20673
20674   jresult = result;
20675   return jresult;
20676 }
20677
20678
20679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20680   int jresult ;
20681   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20682   Dali::Property::Index arg2 ;
20683   Dali::Property::Type result;
20684
20685   arg1 = (Dali::Handle *)jarg1;
20686   arg2 = (Dali::Property::Index)jarg2;
20687   {
20688     try {
20689       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20690     } catch (std::out_of_range& e) {
20691       {
20692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20693       };
20694     } catch (std::exception& e) {
20695       {
20696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (Dali::DaliException e) {
20699       {
20700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20701       };
20702     } catch (...) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20705       };
20706     }
20707   }
20708
20709   jresult = (int)result;
20710   return jresult;
20711 }
20712
20713
20714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20715   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20716   Dali::Property::Index arg2 ;
20717   Dali::Property::Value *arg3 = 0 ;
20718
20719   arg1 = (Dali::Handle *)jarg1;
20720   arg2 = (Dali::Property::Index)jarg2;
20721   arg3 = (Dali::Property::Value *)jarg3;
20722   if (!arg3) {
20723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20724     return ;
20725   }
20726   {
20727     try {
20728       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20729     } catch (std::out_of_range& e) {
20730       {
20731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20732       };
20733     } catch (std::exception& e) {
20734       {
20735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (Dali::DaliException e) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20740       };
20741     } catch (...) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20744       };
20745     }
20746   }
20747
20748 }
20749
20750
20751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20752   int jresult ;
20753   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20754   std::string *arg2 = 0 ;
20755   Dali::Property::Value *arg3 = 0 ;
20756   Dali::Property::Index result;
20757
20758   arg1 = (Dali::Handle *)jarg1;
20759   if (!jarg2) {
20760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20761     return 0;
20762   }
20763   std::string arg2_str(jarg2);
20764   arg2 = &arg2_str;
20765   arg3 = (Dali::Property::Value *)jarg3;
20766   if (!arg3) {
20767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20768     return 0;
20769   }
20770   {
20771     try {
20772       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20773     } catch (std::out_of_range& e) {
20774       {
20775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20776       };
20777     } catch (std::exception& e) {
20778       {
20779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (Dali::DaliException e) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20784       };
20785     } catch (...) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20788       };
20789     }
20790   }
20791
20792   jresult = result;
20793
20794   //argout typemap for const std::string&
20795
20796   return jresult;
20797 }
20798
20799
20800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20801   int jresult ;
20802   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20803   std::string *arg2 = 0 ;
20804   Dali::Property::Value *arg3 = 0 ;
20805   Dali::Property::AccessMode arg4 ;
20806   Dali::Property::Index result;
20807
20808   arg1 = (Dali::Handle *)jarg1;
20809   if (!jarg2) {
20810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20811     return 0;
20812   }
20813   std::string arg2_str(jarg2);
20814   arg2 = &arg2_str;
20815   arg3 = (Dali::Property::Value *)jarg3;
20816   if (!arg3) {
20817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20818     return 0;
20819   }
20820   arg4 = (Dali::Property::AccessMode)jarg4;
20821   {
20822     try {
20823       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20824     } catch (std::out_of_range& e) {
20825       {
20826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20827       };
20828     } catch (std::exception& e) {
20829       {
20830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (Dali::DaliException e) {
20833       {
20834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20835       };
20836     } catch (...) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20839       };
20840     }
20841   }
20842
20843   jresult = result;
20844
20845   //argout typemap for const std::string&
20846
20847   return jresult;
20848 }
20849
20850
20851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20852   void * jresult ;
20853   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20854   Dali::Property::Index arg2 ;
20855   Dali::Property::Value result;
20856
20857   arg1 = (Dali::Handle *)jarg1;
20858   arg2 = (Dali::Property::Index)jarg2;
20859   {
20860     try {
20861       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20862     } catch (std::out_of_range& e) {
20863       {
20864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20865       };
20866     } catch (std::exception& e) {
20867       {
20868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (Dali::DaliException e) {
20871       {
20872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20873       };
20874     } catch (...) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20877       };
20878     }
20879   }
20880
20881   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20882   return jresult;
20883 }
20884
20885
20886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20887   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20888   Dali::Property::IndexContainer *arg2 = 0 ;
20889
20890   arg1 = (Dali::Handle *)jarg1;
20891   arg2 = (Dali::Property::IndexContainer *)jarg2;
20892   if (!arg2) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20894     return ;
20895   }
20896   {
20897     try {
20898       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20899     } catch (std::out_of_range& e) {
20900       {
20901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20902       };
20903     } catch (std::exception& e) {
20904       {
20905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (Dali::DaliException e) {
20908       {
20909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20910       };
20911     } catch (...) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20914       };
20915     }
20916   }
20917
20918 }
20919
20920
20921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20922   void * jresult ;
20923   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20924   Dali::Property::Index arg2 ;
20925   Dali::PropertyCondition *arg3 = 0 ;
20926   Dali::PropertyNotification result;
20927
20928   arg1 = (Dali::Handle *)jarg1;
20929   arg2 = (Dali::Property::Index)jarg2;
20930   arg3 = (Dali::PropertyCondition *)jarg3;
20931   if (!arg3) {
20932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20933     return 0;
20934   }
20935   {
20936     try {
20937       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20938     } catch (std::out_of_range& e) {
20939       {
20940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20941       };
20942     } catch (std::exception& e) {
20943       {
20944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (Dali::DaliException e) {
20947       {
20948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20949       };
20950     } catch (...) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20953       };
20954     }
20955   }
20956
20957   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20963   void * jresult ;
20964   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20965   Dali::Property::Index arg2 ;
20966   int arg3 ;
20967   Dali::PropertyCondition *arg4 = 0 ;
20968   Dali::PropertyNotification result;
20969
20970   arg1 = (Dali::Handle *)jarg1;
20971   arg2 = (Dali::Property::Index)jarg2;
20972   arg3 = (int)jarg3;
20973   arg4 = (Dali::PropertyCondition *)jarg4;
20974   if (!arg4) {
20975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20976     return 0;
20977   }
20978   {
20979     try {
20980       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20981     } catch (std::out_of_range& e) {
20982       {
20983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20984       };
20985     } catch (std::exception& e) {
20986       {
20987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (Dali::DaliException e) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20992       };
20993     } catch (...) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20996       };
20997     }
20998   }
20999
21000   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21001   return jresult;
21002 }
21003
21004
21005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21006   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21007   Dali::PropertyNotification arg2 ;
21008   Dali::PropertyNotification *argp2 ;
21009
21010   arg1 = (Dali::Handle *)jarg1;
21011   argp2 = (Dali::PropertyNotification *)jarg2;
21012   if (!argp2) {
21013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21014     return ;
21015   }
21016   arg2 = *argp2;
21017   {
21018     try {
21019       (arg1)->RemovePropertyNotification(arg2);
21020     } catch (std::out_of_range& e) {
21021       {
21022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21023       };
21024     } catch (std::exception& e) {
21025       {
21026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (Dali::DaliException e) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21031       };
21032     } catch (...) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21035       };
21036     }
21037   }
21038
21039 }
21040
21041
21042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21043   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21044
21045   arg1 = (Dali::Handle *)jarg1;
21046   {
21047     try {
21048       (arg1)->RemovePropertyNotifications();
21049     } catch (std::out_of_range& e) {
21050       {
21051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21052       };
21053     } catch (std::exception& e) {
21054       {
21055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (Dali::DaliException e) {
21058       {
21059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21060       };
21061     } catch (...) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21064       };
21065     }
21066   }
21067
21068 }
21069
21070
21071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21072   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21073
21074   arg1 = (Dali::Handle *)jarg1;
21075   {
21076     try {
21077       (arg1)->RemoveConstraints();
21078     } catch (std::out_of_range& e) {
21079       {
21080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21081       };
21082     } catch (std::exception& e) {
21083       {
21084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (Dali::DaliException e) {
21087       {
21088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21089       };
21090     } catch (...) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21093       };
21094     }
21095   }
21096
21097 }
21098
21099
21100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21101   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21102   unsigned int arg2 ;
21103
21104   arg1 = (Dali::Handle *)jarg1;
21105   arg2 = (unsigned int)jarg2;
21106   {
21107     try {
21108       (arg1)->RemoveConstraints(arg2);
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (Dali::DaliException e) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21120       };
21121     } catch (...) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21124       };
21125     }
21126   }
21127
21128 }
21129
21130
21131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21132   int jresult ;
21133   Dali::Property::Index result;
21134
21135   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21136   jresult = result;
21137   return jresult;
21138 }
21139
21140
21141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21142   void * jresult ;
21143   Dali::Handle result;
21144
21145   {
21146     try {
21147       result = Dali::WeightObject::New();
21148     } catch (std::out_of_range& e) {
21149       {
21150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21151       };
21152     } catch (std::exception& e) {
21153       {
21154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (Dali::DaliException e) {
21157       {
21158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21159       };
21160     } catch (...) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21163       };
21164     }
21165   }
21166
21167   jresult = new Dali::Handle((const Dali::Handle &)result);
21168   return jresult;
21169 }
21170
21171
21172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21173   void * jresult ;
21174   Dali::TypeInfo *result = 0 ;
21175
21176   {
21177     try {
21178       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21179     } catch (std::out_of_range& e) {
21180       {
21181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21182       };
21183     } catch (std::exception& e) {
21184       {
21185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (Dali::DaliException e) {
21188       {
21189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21190       };
21191     } catch (...) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21194       };
21195     }
21196   }
21197
21198   jresult = (void *)result;
21199   return jresult;
21200 }
21201
21202
21203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21204   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21205
21206   arg1 = (Dali::TypeInfo *)jarg1;
21207   {
21208     try {
21209       delete arg1;
21210     } catch (std::out_of_range& e) {
21211       {
21212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21213       };
21214     } catch (std::exception& e) {
21215       {
21216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (Dali::DaliException e) {
21219       {
21220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21221       };
21222     } catch (...) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21225       };
21226     }
21227   }
21228
21229 }
21230
21231
21232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21233   void * jresult ;
21234   Dali::TypeInfo *arg1 = 0 ;
21235   Dali::TypeInfo *result = 0 ;
21236
21237   arg1 = (Dali::TypeInfo *)jarg1;
21238   if (!arg1) {
21239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21240     return 0;
21241   }
21242   {
21243     try {
21244       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21245     } catch (std::out_of_range& e) {
21246       {
21247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21248       };
21249     } catch (std::exception& e) {
21250       {
21251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (Dali::DaliException e) {
21254       {
21255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21256       };
21257     } catch (...) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21260       };
21261     }
21262   }
21263
21264   jresult = (void *)result;
21265   return jresult;
21266 }
21267
21268
21269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21270   void * jresult ;
21271   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21272   Dali::TypeInfo *arg2 = 0 ;
21273   Dali::TypeInfo *result = 0 ;
21274
21275   arg1 = (Dali::TypeInfo *)jarg1;
21276   arg2 = (Dali::TypeInfo *)jarg2;
21277   if (!arg2) {
21278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21279     return 0;
21280   }
21281   {
21282     try {
21283       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21284     } catch (std::out_of_range& e) {
21285       {
21286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21287       };
21288     } catch (std::exception& e) {
21289       {
21290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (Dali::DaliException e) {
21293       {
21294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21295       };
21296     } catch (...) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21299       };
21300     }
21301   }
21302
21303   jresult = (void *)result;
21304   return jresult;
21305 }
21306
21307
21308 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21309   char * jresult ;
21310   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21311   std::string *result = 0 ;
21312
21313   arg1 = (Dali::TypeInfo *)jarg1;
21314   {
21315     try {
21316       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21317     } catch (std::out_of_range& e) {
21318       {
21319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21320       };
21321     } catch (std::exception& e) {
21322       {
21323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (Dali::DaliException e) {
21326       {
21327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21328       };
21329     } catch (...) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21332       };
21333     }
21334   }
21335
21336   jresult = SWIG_csharp_string_callback(result->c_str());
21337   return jresult;
21338 }
21339
21340
21341 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21342   char * jresult ;
21343   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21344   std::string *result = 0 ;
21345
21346   arg1 = (Dali::TypeInfo *)jarg1;
21347   {
21348     try {
21349       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21350     } catch (std::out_of_range& e) {
21351       {
21352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21353       };
21354     } catch (std::exception& e) {
21355       {
21356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (Dali::DaliException e) {
21359       {
21360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21361       };
21362     } catch (...) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21365       };
21366     }
21367   }
21368
21369   jresult = SWIG_csharp_string_callback(result->c_str());
21370   return jresult;
21371 }
21372
21373
21374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21375   void * jresult ;
21376   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21377   Dali::BaseHandle result;
21378
21379   arg1 = (Dali::TypeInfo *)jarg1;
21380   {
21381     try {
21382       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21383     } catch (std::out_of_range& e) {
21384       {
21385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21386       };
21387     } catch (std::exception& e) {
21388       {
21389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (Dali::DaliException e) {
21392       {
21393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21394       };
21395     } catch (...) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21398       };
21399     }
21400   }
21401
21402   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21403   return jresult;
21404 }
21405
21406
21407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21408   unsigned long jresult ;
21409   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21410   size_t result;
21411
21412   arg1 = (Dali::TypeInfo *)jarg1;
21413   {
21414     try {
21415       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21416     } catch (std::out_of_range& e) {
21417       {
21418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21419       };
21420     } catch (std::exception& e) {
21421       {
21422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (Dali::DaliException e) {
21425       {
21426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21427       };
21428     } catch (...) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21431       };
21432     }
21433   }
21434
21435   jresult = (unsigned long)result;
21436   return jresult;
21437 }
21438
21439
21440 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21441   char * jresult ;
21442   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21443   size_t arg2 ;
21444   std::string result;
21445
21446   arg1 = (Dali::TypeInfo *)jarg1;
21447   arg2 = (size_t)jarg2;
21448   {
21449     try {
21450       result = (arg1)->GetActionName(arg2);
21451     } catch (std::out_of_range& e) {
21452       {
21453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21454       };
21455     } catch (std::exception& e) {
21456       {
21457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (Dali::DaliException e) {
21460       {
21461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21462       };
21463     } catch (...) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21466       };
21467     }
21468   }
21469
21470   jresult = SWIG_csharp_string_callback((&result)->c_str());
21471   return jresult;
21472 }
21473
21474
21475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21476   unsigned long jresult ;
21477   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21478   size_t result;
21479
21480   arg1 = (Dali::TypeInfo *)jarg1;
21481   {
21482     try {
21483       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21484     } catch (std::out_of_range& e) {
21485       {
21486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21487       };
21488     } catch (std::exception& e) {
21489       {
21490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (Dali::DaliException e) {
21493       {
21494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21495       };
21496     } catch (...) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21499       };
21500     }
21501   }
21502
21503   jresult = (unsigned long)result;
21504   return jresult;
21505 }
21506
21507
21508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21509   char * jresult ;
21510   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21511   size_t arg2 ;
21512   std::string result;
21513
21514   arg1 = (Dali::TypeInfo *)jarg1;
21515   arg2 = (size_t)jarg2;
21516   {
21517     try {
21518       result = (arg1)->GetSignalName(arg2);
21519     } catch (std::out_of_range& e) {
21520       {
21521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21522       };
21523     } catch (std::exception& e) {
21524       {
21525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (Dali::DaliException e) {
21528       {
21529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21530       };
21531     } catch (...) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21534       };
21535     }
21536   }
21537
21538   jresult = SWIG_csharp_string_callback((&result)->c_str());
21539   return jresult;
21540 }
21541
21542
21543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21544   unsigned long jresult ;
21545   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21546   size_t result;
21547
21548   arg1 = (Dali::TypeInfo *)jarg1;
21549   {
21550     try {
21551       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21552     } catch (std::out_of_range& e) {
21553       {
21554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (std::exception& e) {
21557       {
21558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (Dali::DaliException e) {
21561       {
21562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21563       };
21564     } catch (...) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21567       };
21568     }
21569   }
21570
21571   jresult = (unsigned long)result;
21572   return jresult;
21573 }
21574
21575
21576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21577   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21578   Dali::Property::IndexContainer *arg2 = 0 ;
21579
21580   arg1 = (Dali::TypeInfo *)jarg1;
21581   arg2 = (Dali::Property::IndexContainer *)jarg2;
21582   if (!arg2) {
21583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21584     return ;
21585   }
21586   {
21587     try {
21588       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21589     } catch (std::out_of_range& e) {
21590       {
21591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21592       };
21593     } catch (std::exception& e) {
21594       {
21595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (Dali::DaliException e) {
21598       {
21599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21600       };
21601     } catch (...) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21604       };
21605     }
21606   }
21607
21608 }
21609
21610
21611 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21612   char * jresult ;
21613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21614   Dali::Property::Index arg2 ;
21615   std::string *result = 0 ;
21616
21617   arg1 = (Dali::TypeInfo *)jarg1;
21618   arg2 = (Dali::Property::Index)jarg2;
21619   {
21620     try {
21621       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21622     } catch (std::out_of_range& e) {
21623       {
21624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21625       };
21626     } catch (std::exception& e) {
21627       {
21628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (Dali::DaliException e) {
21631       {
21632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21633       };
21634     } catch (...) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21637       };
21638     }
21639   }
21640
21641   jresult = SWIG_csharp_string_callback(result->c_str());
21642   return jresult;
21643 }
21644
21645
21646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21647   void * jresult ;
21648   Dali::TypeRegistry result;
21649
21650   {
21651     try {
21652       result = Dali::TypeRegistry::Get();
21653     } catch (std::out_of_range& e) {
21654       {
21655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21656       };
21657     } catch (std::exception& e) {
21658       {
21659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (Dali::DaliException e) {
21662       {
21663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21664       };
21665     } catch (...) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21668       };
21669     }
21670   }
21671
21672   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21673   return jresult;
21674 }
21675
21676
21677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21678   void * jresult ;
21679   Dali::TypeRegistry *result = 0 ;
21680
21681   {
21682     try {
21683       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21684     } catch (std::out_of_range& e) {
21685       {
21686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21687       };
21688     } catch (std::exception& e) {
21689       {
21690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (Dali::DaliException e) {
21693       {
21694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21695       };
21696     } catch (...) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21699       };
21700     }
21701   }
21702
21703   jresult = (void *)result;
21704   return jresult;
21705 }
21706
21707
21708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21709   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21710
21711   arg1 = (Dali::TypeRegistry *)jarg1;
21712   {
21713     try {
21714       delete arg1;
21715     } catch (std::out_of_range& e) {
21716       {
21717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21718       };
21719     } catch (std::exception& e) {
21720       {
21721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (Dali::DaliException e) {
21724       {
21725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21726       };
21727     } catch (...) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21730       };
21731     }
21732   }
21733
21734 }
21735
21736
21737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21738   void * jresult ;
21739   Dali::TypeRegistry *arg1 = 0 ;
21740   Dali::TypeRegistry *result = 0 ;
21741
21742   arg1 = (Dali::TypeRegistry *)jarg1;
21743   if (!arg1) {
21744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21745     return 0;
21746   }
21747   {
21748     try {
21749       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21750     } catch (std::out_of_range& e) {
21751       {
21752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21753       };
21754     } catch (std::exception& e) {
21755       {
21756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (Dali::DaliException e) {
21759       {
21760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21761       };
21762     } catch (...) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21765       };
21766     }
21767   }
21768
21769   jresult = (void *)result;
21770   return jresult;
21771 }
21772
21773
21774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21775   void * jresult ;
21776   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21777   Dali::TypeRegistry *arg2 = 0 ;
21778   Dali::TypeRegistry *result = 0 ;
21779
21780   arg1 = (Dali::TypeRegistry *)jarg1;
21781   arg2 = (Dali::TypeRegistry *)jarg2;
21782   if (!arg2) {
21783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21784     return 0;
21785   }
21786   {
21787     try {
21788       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21789     } catch (std::out_of_range& e) {
21790       {
21791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21792       };
21793     } catch (std::exception& e) {
21794       {
21795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (Dali::DaliException e) {
21798       {
21799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21800       };
21801     } catch (...) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21804       };
21805     }
21806   }
21807
21808   jresult = (void *)result;
21809   return jresult;
21810 }
21811
21812
21813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21814   void * jresult ;
21815   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21816   std::string *arg2 = 0 ;
21817   Dali::TypeInfo result;
21818
21819   arg1 = (Dali::TypeRegistry *)jarg1;
21820   if (!jarg2) {
21821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21822     return 0;
21823   }
21824   std::string arg2_str(jarg2);
21825   arg2 = &arg2_str;
21826   {
21827     try {
21828       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21829     } catch (std::out_of_range& e) {
21830       {
21831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (std::exception& e) {
21834       {
21835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (Dali::DaliException e) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847
21848   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21849
21850   //argout typemap for const std::string&
21851
21852   return jresult;
21853 }
21854
21855
21856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21857   void * jresult ;
21858   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21859   std::type_info *arg2 = 0 ;
21860   Dali::TypeInfo result;
21861
21862   arg1 = (Dali::TypeRegistry *)jarg1;
21863   arg2 = (std::type_info *)jarg2;
21864   if (!arg2) {
21865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21866     return 0;
21867   }
21868   {
21869     try {
21870       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21871     } catch (std::out_of_range& e) {
21872       {
21873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21874       };
21875     } catch (std::exception& e) {
21876       {
21877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (Dali::DaliException e) {
21880       {
21881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21882       };
21883     } catch (...) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21886       };
21887     }
21888   }
21889
21890   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21891   return jresult;
21892 }
21893
21894
21895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21896   unsigned long jresult ;
21897   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21898   size_t result;
21899
21900   arg1 = (Dali::TypeRegistry *)jarg1;
21901   {
21902     try {
21903       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21904     } catch (std::out_of_range& e) {
21905       {
21906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21907       };
21908     } catch (std::exception& e) {
21909       {
21910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (Dali::DaliException e) {
21913       {
21914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21915       };
21916     } catch (...) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21919       };
21920     }
21921   }
21922
21923   jresult = (unsigned long)result;
21924   return jresult;
21925 }
21926
21927
21928 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21929   char * jresult ;
21930   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21931   size_t arg2 ;
21932   std::string result;
21933
21934   arg1 = (Dali::TypeRegistry *)jarg1;
21935   arg2 = (size_t)jarg2;
21936   {
21937     try {
21938       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21939     } catch (std::out_of_range& e) {
21940       {
21941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21942       };
21943     } catch (std::exception& e) {
21944       {
21945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (Dali::DaliException e) {
21948       {
21949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21950       };
21951     } catch (...) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21954       };
21955     }
21956   }
21957
21958   jresult = SWIG_csharp_string_callback((&result)->c_str());
21959   return jresult;
21960 }
21961
21962
21963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21964   void * jresult ;
21965   std::type_info *arg1 = 0 ;
21966   std::type_info *arg2 = 0 ;
21967   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21968   Dali::TypeRegistration *result = 0 ;
21969
21970   arg1 = (std::type_info *)jarg1;
21971   if (!arg1) {
21972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21973     return 0;
21974   }
21975   arg2 = (std::type_info *)jarg2;
21976   if (!arg2) {
21977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21978     return 0;
21979   }
21980   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21981   {
21982     try {
21983       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21984     } catch (std::out_of_range& e) {
21985       {
21986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21987       };
21988     } catch (std::exception& e) {
21989       {
21990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (Dali::DaliException e) {
21993       {
21994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21995       };
21996     } catch (...) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21999       };
22000     }
22001   }
22002
22003   jresult = (void *)result;
22004   return jresult;
22005 }
22006
22007
22008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22009   void * jresult ;
22010   std::type_info *arg1 = 0 ;
22011   std::type_info *arg2 = 0 ;
22012   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22013   bool arg4 ;
22014   Dali::TypeRegistration *result = 0 ;
22015
22016   arg1 = (std::type_info *)jarg1;
22017   if (!arg1) {
22018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22019     return 0;
22020   }
22021   arg2 = (std::type_info *)jarg2;
22022   if (!arg2) {
22023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22024     return 0;
22025   }
22026   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22027   arg4 = jarg4 ? true : false;
22028   {
22029     try {
22030       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22031     } catch (std::out_of_range& e) {
22032       {
22033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22034       };
22035     } catch (std::exception& e) {
22036       {
22037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (Dali::DaliException e) {
22040       {
22041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22042       };
22043     } catch (...) {
22044       {
22045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22046       };
22047     }
22048   }
22049
22050   jresult = (void *)result;
22051   return jresult;
22052 }
22053
22054
22055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22056   void * jresult ;
22057   std::string *arg1 = 0 ;
22058   std::type_info *arg2 = 0 ;
22059   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22060   Dali::TypeRegistration *result = 0 ;
22061
22062   if (!jarg1) {
22063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22064     return 0;
22065   }
22066   std::string arg1_str(jarg1);
22067   arg1 = &arg1_str;
22068   arg2 = (std::type_info *)jarg2;
22069   if (!arg2) {
22070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22071     return 0;
22072   }
22073   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22074   {
22075     try {
22076       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22077     } catch (std::out_of_range& e) {
22078       {
22079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22080       };
22081     } catch (std::exception& e) {
22082       {
22083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (Dali::DaliException e) {
22086       {
22087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22088       };
22089     } catch (...) {
22090       {
22091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22092       };
22093     }
22094   }
22095
22096   jresult = (void *)result;
22097
22098   //argout typemap for const std::string&
22099
22100   return jresult;
22101 }
22102
22103
22104 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22105   char * jresult ;
22106   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22107   std::string result;
22108
22109   arg1 = (Dali::TypeRegistration *)jarg1;
22110   {
22111     try {
22112       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22113     } catch (std::out_of_range& e) {
22114       {
22115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22116       };
22117     } catch (std::exception& e) {
22118       {
22119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (Dali::DaliException e) {
22122       {
22123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22124       };
22125     } catch (...) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22128       };
22129     }
22130   }
22131
22132   jresult = SWIG_csharp_string_callback((&result)->c_str());
22133   return jresult;
22134 }
22135
22136
22137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22138   std::string *arg1 = 0 ;
22139   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22140
22141   if (!jarg1) {
22142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22143     return ;
22144   }
22145   std::string arg1_str(jarg1);
22146   arg1 = &arg1_str;
22147   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22148   {
22149     try {
22150       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22151     } catch (std::out_of_range& e) {
22152       {
22153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22154       };
22155     } catch (std::exception& e) {
22156       {
22157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22158       };
22159     } catch (Dali::DaliException e) {
22160       {
22161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22162       };
22163     } catch (...) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22166       };
22167     }
22168   }
22169
22170
22171   //argout typemap for const std::string&
22172
22173 }
22174
22175
22176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22177   std::string *arg1 = 0 ;
22178   std::string *arg2 = 0 ;
22179   int arg3 ;
22180   Dali::Property::Type arg4 ;
22181   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22182   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22183
22184   if (!jarg1) {
22185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22186     return ;
22187   }
22188   std::string arg1_str(jarg1);
22189   arg1 = &arg1_str;
22190   if (!jarg2) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg2_str(jarg2);
22195   arg2 = &arg2_str;
22196   arg3 = (int)jarg3;
22197   arg4 = (Dali::Property::Type)jarg4;
22198   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22199   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22200   {
22201     try {
22202       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22203     } catch (std::out_of_range& e) {
22204       {
22205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22206       };
22207     } catch (std::exception& e) {
22208       {
22209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22210       };
22211     } catch (Dali::DaliException e) {
22212       {
22213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22214       };
22215     } catch (...) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22218       };
22219     }
22220   }
22221
22222
22223   //argout typemap for const std::string&
22224
22225
22226   //argout typemap for const std::string&
22227
22228 }
22229
22230
22231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22232   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22233
22234   arg1 = (Dali::TypeRegistration *)jarg1;
22235   {
22236     try {
22237       delete arg1;
22238     } catch (std::out_of_range& e) {
22239       {
22240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22241       };
22242     } catch (std::exception& e) {
22243       {
22244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22245       };
22246     } catch (Dali::DaliException e) {
22247       {
22248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22249       };
22250     } catch (...) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22253       };
22254     }
22255   }
22256
22257 }
22258
22259
22260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22261   void * jresult ;
22262   Dali::TypeRegistration *arg1 = 0 ;
22263   std::string *arg2 = 0 ;
22264   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22265   Dali::SignalConnectorType *result = 0 ;
22266
22267   arg1 = (Dali::TypeRegistration *)jarg1;
22268   if (!arg1) {
22269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22270     return 0;
22271   }
22272   if (!jarg2) {
22273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22274     return 0;
22275   }
22276   std::string arg2_str(jarg2);
22277   arg2 = &arg2_str;
22278   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22279   {
22280     try {
22281       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22282     } catch (std::out_of_range& e) {
22283       {
22284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22285       };
22286     } catch (std::exception& e) {
22287       {
22288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22289       };
22290     } catch (Dali::DaliException e) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22293       };
22294     } catch (...) {
22295       {
22296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22297       };
22298     }
22299   }
22300
22301   jresult = (void *)result;
22302
22303   //argout typemap for const std::string&
22304
22305   return jresult;
22306 }
22307
22308
22309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22310   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22311
22312   arg1 = (Dali::SignalConnectorType *)jarg1;
22313   {
22314     try {
22315       delete arg1;
22316     } catch (std::out_of_range& e) {
22317       {
22318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22319       };
22320     } catch (std::exception& e) {
22321       {
22322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (Dali::DaliException e) {
22325       {
22326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22327       };
22328     } catch (...) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22331       };
22332     }
22333   }
22334
22335 }
22336
22337
22338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22339   void * jresult ;
22340   Dali::TypeRegistration *arg1 = 0 ;
22341   std::string *arg2 = 0 ;
22342   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22343   Dali::TypeAction *result = 0 ;
22344
22345   arg1 = (Dali::TypeRegistration *)jarg1;
22346   if (!arg1) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22348     return 0;
22349   }
22350   if (!jarg2) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22352     return 0;
22353   }
22354   std::string arg2_str(jarg2);
22355   arg2 = &arg2_str;
22356   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22357   {
22358     try {
22359       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22360     } catch (std::out_of_range& e) {
22361       {
22362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22363       };
22364     } catch (std::exception& e) {
22365       {
22366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (Dali::DaliException e) {
22369       {
22370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22371       };
22372     } catch (...) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22375       };
22376     }
22377   }
22378
22379   jresult = (void *)result;
22380
22381   //argout typemap for const std::string&
22382
22383   return jresult;
22384 }
22385
22386
22387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22388   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22389
22390   arg1 = (Dali::TypeAction *)jarg1;
22391   {
22392     try {
22393       delete arg1;
22394     } catch (std::out_of_range& e) {
22395       {
22396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22397       };
22398     } catch (std::exception& e) {
22399       {
22400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (Dali::DaliException e) {
22403       {
22404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22405       };
22406     } catch (...) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22409       };
22410     }
22411   }
22412
22413 }
22414
22415
22416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22417   void * jresult ;
22418   Dali::TypeRegistration *arg1 = 0 ;
22419   std::string *arg2 = 0 ;
22420   Dali::Property::Index arg3 ;
22421   Dali::Property::Type arg4 ;
22422   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22423   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22424   Dali::PropertyRegistration *result = 0 ;
22425
22426   arg1 = (Dali::TypeRegistration *)jarg1;
22427   if (!arg1) {
22428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22429     return 0;
22430   }
22431   if (!jarg2) {
22432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22433     return 0;
22434   }
22435   std::string arg2_str(jarg2);
22436   arg2 = &arg2_str;
22437   arg3 = (Dali::Property::Index)jarg3;
22438   arg4 = (Dali::Property::Type)jarg4;
22439   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22440   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22441   {
22442     try {
22443       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22444     } catch (std::out_of_range& e) {
22445       {
22446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22447       };
22448     } catch (std::exception& e) {
22449       {
22450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (Dali::DaliException e) {
22453       {
22454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22455       };
22456     } catch (...) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22459       };
22460     }
22461   }
22462
22463   jresult = (void *)result;
22464
22465   //argout typemap for const std::string&
22466
22467   return jresult;
22468 }
22469
22470
22471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22472   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22473
22474   arg1 = (Dali::PropertyRegistration *)jarg1;
22475   {
22476     try {
22477       delete arg1;
22478     } catch (std::out_of_range& e) {
22479       {
22480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22481       };
22482     } catch (std::exception& e) {
22483       {
22484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (Dali::DaliException e) {
22487       {
22488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22489       };
22490     } catch (...) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22493       };
22494     }
22495   }
22496
22497 }
22498
22499
22500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22501   void * jresult ;
22502   Dali::TypeRegistration *arg1 = 0 ;
22503   std::string *arg2 = 0 ;
22504   Dali::Property::Index arg3 ;
22505   Dali::Property::Type arg4 ;
22506   Dali::AnimatablePropertyRegistration *result = 0 ;
22507
22508   arg1 = (Dali::TypeRegistration *)jarg1;
22509   if (!arg1) {
22510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22511     return 0;
22512   }
22513   if (!jarg2) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22515     return 0;
22516   }
22517   std::string arg2_str(jarg2);
22518   arg2 = &arg2_str;
22519   arg3 = (Dali::Property::Index)jarg3;
22520   arg4 = (Dali::Property::Type)jarg4;
22521   {
22522     try {
22523       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22524     } catch (std::out_of_range& e) {
22525       {
22526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22527       };
22528     } catch (std::exception& e) {
22529       {
22530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22531       };
22532     } catch (Dali::DaliException e) {
22533       {
22534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22535       };
22536     } catch (...) {
22537       {
22538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22539       };
22540     }
22541   }
22542
22543   jresult = (void *)result;
22544
22545   //argout typemap for const std::string&
22546
22547   return jresult;
22548 }
22549
22550
22551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22552   void * jresult ;
22553   Dali::TypeRegistration *arg1 = 0 ;
22554   std::string *arg2 = 0 ;
22555   Dali::Property::Index arg3 ;
22556   Dali::Property::Value *arg4 = 0 ;
22557   Dali::AnimatablePropertyRegistration *result = 0 ;
22558
22559   arg1 = (Dali::TypeRegistration *)jarg1;
22560   if (!arg1) {
22561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22562     return 0;
22563   }
22564   if (!jarg2) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22566     return 0;
22567   }
22568   std::string arg2_str(jarg2);
22569   arg2 = &arg2_str;
22570   arg3 = (Dali::Property::Index)jarg3;
22571   arg4 = (Dali::Property::Value *)jarg4;
22572   if (!arg4) {
22573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22574     return 0;
22575   }
22576   {
22577     try {
22578       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22579     } catch (std::out_of_range& e) {
22580       {
22581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22582       };
22583     } catch (std::exception& e) {
22584       {
22585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (Dali::DaliException e) {
22588       {
22589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22590       };
22591     } catch (...) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22594       };
22595     }
22596   }
22597
22598   jresult = (void *)result;
22599
22600   //argout typemap for const std::string&
22601
22602   return jresult;
22603 }
22604
22605
22606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22607   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22608
22609   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22610   {
22611     try {
22612       delete arg1;
22613     } catch (std::out_of_range& e) {
22614       {
22615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22616       };
22617     } catch (std::exception& e) {
22618       {
22619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (Dali::DaliException e) {
22622       {
22623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22624       };
22625     } catch (...) {
22626       {
22627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22628       };
22629     }
22630   }
22631
22632 }
22633
22634
22635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22636   void * jresult ;
22637   Dali::TypeRegistration *arg1 = 0 ;
22638   std::string *arg2 = 0 ;
22639   Dali::Property::Index arg3 ;
22640   Dali::Property::Index arg4 ;
22641   unsigned int arg5 ;
22642   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22643
22644   arg1 = (Dali::TypeRegistration *)jarg1;
22645   if (!arg1) {
22646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22647     return 0;
22648   }
22649   if (!jarg2) {
22650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22651     return 0;
22652   }
22653   std::string arg2_str(jarg2);
22654   arg2 = &arg2_str;
22655   arg3 = (Dali::Property::Index)jarg3;
22656   arg4 = (Dali::Property::Index)jarg4;
22657   arg5 = (unsigned int)jarg5;
22658   {
22659     try {
22660       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22661     } catch (std::out_of_range& e) {
22662       {
22663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (std::exception& e) {
22666       {
22667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (Dali::DaliException e) {
22670       {
22671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22672       };
22673     } catch (...) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22676       };
22677     }
22678   }
22679
22680   jresult = (void *)result;
22681
22682   //argout typemap for const std::string&
22683
22684   return jresult;
22685 }
22686
22687
22688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22689   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22690
22691   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22692   {
22693     try {
22694       delete arg1;
22695     } catch (std::out_of_range& e) {
22696       {
22697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22698       };
22699     } catch (std::exception& e) {
22700       {
22701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (Dali::DaliException e) {
22704       {
22705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22706       };
22707     } catch (...) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22710       };
22711     }
22712   }
22713
22714 }
22715
22716
22717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22718   void * jresult ;
22719   Dali::TypeRegistration *arg1 = 0 ;
22720   std::string *arg2 = 0 ;
22721   Dali::Property::Index arg3 ;
22722   Dali::Property::Type arg4 ;
22723   Dali::ChildPropertyRegistration *result = 0 ;
22724
22725   arg1 = (Dali::TypeRegistration *)jarg1;
22726   if (!arg1) {
22727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22728     return 0;
22729   }
22730   if (!jarg2) {
22731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22732     return 0;
22733   }
22734   std::string arg2_str(jarg2);
22735   arg2 = &arg2_str;
22736   arg3 = (Dali::Property::Index)jarg3;
22737   arg4 = (Dali::Property::Type)jarg4;
22738   {
22739     try {
22740       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22741     } catch (std::out_of_range& e) {
22742       {
22743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22744       };
22745     } catch (std::exception& e) {
22746       {
22747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22748       };
22749     } catch (Dali::DaliException e) {
22750       {
22751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22752       };
22753     } catch (...) {
22754       {
22755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22756       };
22757     }
22758   }
22759
22760   jresult = (void *)result;
22761
22762   //argout typemap for const std::string&
22763
22764   return jresult;
22765 }
22766
22767
22768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22769   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22770
22771   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22772   {
22773     try {
22774       delete arg1;
22775     } catch (std::out_of_range& e) {
22776       {
22777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22778       };
22779     } catch (std::exception& e) {
22780       {
22781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22782       };
22783     } catch (Dali::DaliException e) {
22784       {
22785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22786       };
22787     } catch (...) {
22788       {
22789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22790       };
22791     }
22792   }
22793
22794 }
22795
22796
22797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22798   unsigned int jresult ;
22799   std::string *arg1 = 0 ;
22800   std::type_info *arg2 = 0 ;
22801   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22802   bool result;
22803
22804   if (!jarg1) {
22805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22806     return 0;
22807   }
22808   std::string arg1_str(jarg1);
22809   arg1 = &arg1_str;
22810   arg2 = (std::type_info *)jarg2;
22811   if (!arg2) {
22812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22813     return 0;
22814   }
22815   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22816   {
22817     try {
22818       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22819     } catch (std::out_of_range& e) {
22820       {
22821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (std::exception& e) {
22824       {
22825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (Dali::DaliException e) {
22828       {
22829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22830       };
22831     } catch (...) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22834       };
22835     }
22836   }
22837
22838   jresult = result;
22839
22840   //argout typemap for const std::string&
22841
22842   return jresult;
22843 }
22844
22845
22846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22847   unsigned int jresult ;
22848   std::string *arg1 = 0 ;
22849   std::string *arg2 = 0 ;
22850   Dali::Property::Index arg3 ;
22851   Dali::Property::Type arg4 ;
22852   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22853   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22854   bool result;
22855
22856   if (!jarg1) {
22857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22858     return 0;
22859   }
22860   std::string arg1_str(jarg1);
22861   arg1 = &arg1_str;
22862   if (!jarg2) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22864     return 0;
22865   }
22866   std::string arg2_str(jarg2);
22867   arg2 = &arg2_str;
22868   arg3 = (Dali::Property::Index)jarg3;
22869   arg4 = (Dali::Property::Type)jarg4;
22870   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22871   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22872   {
22873     try {
22874       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22875     } catch (std::out_of_range& e) {
22876       {
22877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22878       };
22879     } catch (std::exception& e) {
22880       {
22881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (Dali::DaliException e) {
22884       {
22885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22886       };
22887     } catch (...) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22890       };
22891     }
22892   }
22893
22894   jresult = result;
22895
22896   //argout typemap for const std::string&
22897
22898
22899   //argout typemap for const std::string&
22900
22901   return jresult;
22902 }
22903
22904
22905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22906   float jresult ;
22907   float result;
22908
22909   result = (float)(float)Dali::ParentOrigin::TOP;
22910   jresult = result;
22911   return jresult;
22912 }
22913
22914
22915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22916   float jresult ;
22917   float result;
22918
22919   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22920   jresult = result;
22921   return jresult;
22922 }
22923
22924
22925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22926   float jresult ;
22927   float result;
22928
22929   result = (float)(float)Dali::ParentOrigin::LEFT;
22930   jresult = result;
22931   return jresult;
22932 }
22933
22934
22935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22936   float jresult ;
22937   float result;
22938
22939   result = (float)(float)Dali::ParentOrigin::RIGHT;
22940   jresult = result;
22941   return jresult;
22942 }
22943
22944
22945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22946   float jresult ;
22947   float result;
22948
22949   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22950   jresult = result;
22951   return jresult;
22952 }
22953
22954
22955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22956   void * jresult ;
22957   Dali::Vector3 *result = 0 ;
22958
22959   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22960   jresult = (void *)result;
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22966   void * jresult ;
22967   Dali::Vector3 *result = 0 ;
22968
22969   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22970   jresult = (void *)result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22976   void * jresult ;
22977   Dali::Vector3 *result = 0 ;
22978
22979   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22980   jresult = (void *)result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22986   void * jresult ;
22987   Dali::Vector3 *result = 0 ;
22988
22989   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22990   jresult = (void *)result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22996   void * jresult ;
22997   Dali::Vector3 *result = 0 ;
22998
22999   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23000   jresult = (void *)result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23006   void * jresult ;
23007   Dali::Vector3 *result = 0 ;
23008
23009   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23010   jresult = (void *)result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23016   void * jresult ;
23017   Dali::Vector3 *result = 0 ;
23018
23019   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23020   jresult = (void *)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23026   void * jresult ;
23027   Dali::Vector3 *result = 0 ;
23028
23029   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23030   jresult = (void *)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23036   void * jresult ;
23037   Dali::Vector3 *result = 0 ;
23038
23039   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23046   float jresult ;
23047   float result;
23048
23049   result = (float)(float)Dali::AnchorPoint::TOP;
23050   jresult = result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23056   float jresult ;
23057   float result;
23058
23059   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23060   jresult = result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23066   float jresult ;
23067   float result;
23068
23069   result = (float)(float)Dali::AnchorPoint::LEFT;
23070   jresult = result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23076   float jresult ;
23077   float result;
23078
23079   result = (float)(float)Dali::AnchorPoint::RIGHT;
23080   jresult = result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23086   float jresult ;
23087   float result;
23088
23089   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23090   jresult = result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23096   void * jresult ;
23097   Dali::Vector3 *result = 0 ;
23098
23099   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23100   jresult = (void *)result;
23101   return jresult;
23102 }
23103
23104
23105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23106   void * jresult ;
23107   Dali::Vector3 *result = 0 ;
23108
23109   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23110   jresult = (void *)result;
23111   return jresult;
23112 }
23113
23114
23115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23116   void * jresult ;
23117   Dali::Vector3 *result = 0 ;
23118
23119   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23120   jresult = (void *)result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23126   void * jresult ;
23127   Dali::Vector3 *result = 0 ;
23128
23129   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23130   jresult = (void *)result;
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23136   void * jresult ;
23137   Dali::Vector3 *result = 0 ;
23138
23139   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23140   jresult = (void *)result;
23141   return jresult;
23142 }
23143
23144
23145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23146   void * jresult ;
23147   Dali::Vector3 *result = 0 ;
23148
23149   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23150   jresult = (void *)result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23156   void * jresult ;
23157   Dali::Vector3 *result = 0 ;
23158
23159   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23160   jresult = (void *)result;
23161   return jresult;
23162 }
23163
23164
23165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23166   void * jresult ;
23167   Dali::Vector3 *result = 0 ;
23168
23169   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23170   jresult = (void *)result;
23171   return jresult;
23172 }
23173
23174
23175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23176   void * jresult ;
23177   Dali::Vector3 *result = 0 ;
23178
23179   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23180   jresult = (void *)result;
23181   return jresult;
23182 }
23183
23184
23185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23186   void * jresult ;
23187   Dali::Vector4 *result = 0 ;
23188
23189   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23190   jresult = (void *)result;
23191   return jresult;
23192 }
23193
23194
23195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23196   void * jresult ;
23197   Dali::Vector4 *result = 0 ;
23198
23199   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23200   jresult = (void *)result;
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23206   void * jresult ;
23207   Dali::Vector4 *result = 0 ;
23208
23209   result = (Dali::Vector4 *)&Dali::Color::RED;
23210   jresult = (void *)result;
23211   return jresult;
23212 }
23213
23214
23215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23216   void * jresult ;
23217   Dali::Vector4 *result = 0 ;
23218
23219   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23220   jresult = (void *)result;
23221   return jresult;
23222 }
23223
23224
23225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23226   void * jresult ;
23227   Dali::Vector4 *result = 0 ;
23228
23229   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23230   jresult = (void *)result;
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23236   void * jresult ;
23237   Dali::Vector4 *result = 0 ;
23238
23239   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23240   jresult = (void *)result;
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23246   void * jresult ;
23247   Dali::Vector4 *result = 0 ;
23248
23249   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23256   void * jresult ;
23257   Dali::Vector4 *result = 0 ;
23258
23259   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23266   void * jresult ;
23267   Dali::Vector4 *result = 0 ;
23268
23269   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23270   jresult = (void *)result;
23271   return jresult;
23272 }
23273
23274
23275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23276   float jresult ;
23277   float result;
23278
23279   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23280   jresult = result;
23281   return jresult;
23282 }
23283
23284
23285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23286   float jresult ;
23287   float result;
23288
23289   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23290   jresult = result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23296   float jresult ;
23297   float result;
23298
23299   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23300   jresult = result;
23301   return jresult;
23302 }
23303
23304
23305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23306   float jresult ;
23307   float result;
23308
23309   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23310   jresult = result;
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23316   float jresult ;
23317   float result;
23318
23319   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23320   jresult = result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23326   float jresult ;
23327   float result;
23328
23329   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23330   jresult = result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23336   float jresult ;
23337   float result;
23338
23339   result = (float)(float)Dali::Math::PI;
23340   jresult = result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23346   float jresult ;
23347   float result;
23348
23349   result = (float)(float)Dali::Math::PI_2;
23350   jresult = result;
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23356   float jresult ;
23357   float result;
23358
23359   result = (float)(float)Dali::Math::PI_4;
23360   jresult = result;
23361   return jresult;
23362 }
23363
23364
23365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23366   float jresult ;
23367   float result;
23368
23369   result = (float)(float)Dali::Math::PI_OVER_180;
23370   jresult = result;
23371   return jresult;
23372 }
23373
23374
23375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23376   float jresult ;
23377   float result;
23378
23379   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23380   jresult = result;
23381   return jresult;
23382 }
23383
23384
23385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23386   int jresult ;
23387   Dali::ResizePolicy::Type result;
23388
23389   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23390   jresult = (int)result;
23391   return jresult;
23392 }
23393
23394
23395 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23396   unsigned long jresult ;
23397   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23398   Dali::VectorBase::SizeType result;
23399
23400   arg1 = (Dali::VectorBase *)jarg1;
23401   {
23402     try {
23403       result = ((Dali::VectorBase const *)arg1)->Count();
23404     } catch (std::out_of_range& e) {
23405       {
23406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23407       };
23408     } catch (std::exception& e) {
23409       {
23410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23411       };
23412     } catch (Dali::DaliException e) {
23413       {
23414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23415       };
23416     } catch (...) {
23417       {
23418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23419       };
23420     }
23421   }
23422
23423   jresult = (unsigned long)result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23429   unsigned long jresult ;
23430   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23431   Dali::VectorBase::SizeType result;
23432
23433   arg1 = (Dali::VectorBase *)jarg1;
23434   {
23435     try {
23436       result = ((Dali::VectorBase const *)arg1)->Size();
23437     } catch (std::out_of_range& e) {
23438       {
23439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23440       };
23441     } catch (std::exception& e) {
23442       {
23443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (Dali::DaliException e) {
23446       {
23447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23448       };
23449     } catch (...) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23452       };
23453     }
23454   }
23455
23456   jresult = (unsigned long)result;
23457   return jresult;
23458 }
23459
23460
23461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23462   unsigned int jresult ;
23463   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23464   bool result;
23465
23466   arg1 = (Dali::VectorBase *)jarg1;
23467   {
23468     try {
23469       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23470     } catch (std::out_of_range& e) {
23471       {
23472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23473       };
23474     } catch (std::exception& e) {
23475       {
23476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (Dali::DaliException e) {
23479       {
23480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23481       };
23482     } catch (...) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23485       };
23486     }
23487   }
23488
23489   jresult = result;
23490   return jresult;
23491 }
23492
23493
23494 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23495   unsigned long jresult ;
23496   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23497   Dali::VectorBase::SizeType result;
23498
23499   arg1 = (Dali::VectorBase *)jarg1;
23500   {
23501     try {
23502       result = ((Dali::VectorBase const *)arg1)->Capacity();
23503     } catch (std::out_of_range& e) {
23504       {
23505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23506       };
23507     } catch (std::exception& e) {
23508       {
23509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (Dali::DaliException e) {
23512       {
23513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23514       };
23515     } catch (...) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23518       };
23519     }
23520   }
23521
23522   jresult = (unsigned long)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23528   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23529
23530   arg1 = (Dali::VectorBase *)jarg1;
23531   {
23532     try {
23533       (arg1)->Release();
23534     } catch (std::out_of_range& e) {
23535       {
23536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23537       };
23538     } catch (std::exception& e) {
23539       {
23540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23541       };
23542     } catch (Dali::DaliException e) {
23543       {
23544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23545       };
23546     } catch (...) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23549       };
23550     }
23551   }
23552
23553 }
23554
23555
23556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23557   void * jresult ;
23558   Dali::Image *result = 0 ;
23559
23560   {
23561     try {
23562       result = (Dali::Image *)new Dali::Image();
23563     } catch (std::out_of_range& e) {
23564       {
23565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23566       };
23567     } catch (std::exception& e) {
23568       {
23569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (Dali::DaliException e) {
23572       {
23573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23574       };
23575     } catch (...) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23578       };
23579     }
23580   }
23581
23582   jresult = (void *)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23588   Dali::Image *arg1 = (Dali::Image *) 0 ;
23589
23590   arg1 = (Dali::Image *)jarg1;
23591   {
23592     try {
23593       delete arg1;
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (Dali::DaliException e) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23609       };
23610     }
23611   }
23612
23613 }
23614
23615
23616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23617   void * jresult ;
23618   Dali::Image *arg1 = 0 ;
23619   Dali::Image *result = 0 ;
23620
23621   arg1 = (Dali::Image *)jarg1;
23622   if (!arg1) {
23623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23624     return 0;
23625   }
23626   {
23627     try {
23628       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23629     } catch (std::out_of_range& e) {
23630       {
23631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23632       };
23633     } catch (std::exception& e) {
23634       {
23635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (Dali::DaliException e) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23640       };
23641     } catch (...) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23644       };
23645     }
23646   }
23647
23648   jresult = (void *)result;
23649   return jresult;
23650 }
23651
23652
23653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23654   void * jresult ;
23655   Dali::Image *arg1 = (Dali::Image *) 0 ;
23656   Dali::Image *arg2 = 0 ;
23657   Dali::Image *result = 0 ;
23658
23659   arg1 = (Dali::Image *)jarg1;
23660   arg2 = (Dali::Image *)jarg2;
23661   if (!arg2) {
23662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23663     return 0;
23664   }
23665   {
23666     try {
23667       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23668     } catch (std::out_of_range& e) {
23669       {
23670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23671       };
23672     } catch (std::exception& e) {
23673       {
23674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (Dali::DaliException e) {
23677       {
23678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23679       };
23680     } catch (...) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23683       };
23684     }
23685   }
23686
23687   jresult = (void *)result;
23688   return jresult;
23689 }
23690
23691
23692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23693   void * jresult ;
23694   Dali::BaseHandle arg1 ;
23695   Dali::BaseHandle *argp1 ;
23696   Dali::Image result;
23697
23698   argp1 = (Dali::BaseHandle *)jarg1;
23699   if (!argp1) {
23700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23701     return 0;
23702   }
23703   arg1 = *argp1;
23704   {
23705     try {
23706       result = Dali::Image::DownCast(arg1);
23707     } catch (std::out_of_range& e) {
23708       {
23709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23710       };
23711     } catch (std::exception& e) {
23712       {
23713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (Dali::DaliException e) {
23716       {
23717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23718       };
23719     } catch (...) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23722       };
23723     }
23724   }
23725
23726   jresult = new Dali::Image((const Dali::Image &)result);
23727   return jresult;
23728 }
23729
23730
23731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23732   unsigned int jresult ;
23733   Dali::Image *arg1 = (Dali::Image *) 0 ;
23734   unsigned int result;
23735
23736   arg1 = (Dali::Image *)jarg1;
23737   {
23738     try {
23739       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23740     } catch (std::out_of_range& e) {
23741       {
23742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23743       };
23744     } catch (std::exception& e) {
23745       {
23746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (Dali::DaliException e) {
23749       {
23750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23751       };
23752     } catch (...) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23755       };
23756     }
23757   }
23758
23759   jresult = result;
23760   return jresult;
23761 }
23762
23763
23764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23765   unsigned int jresult ;
23766   Dali::Image *arg1 = (Dali::Image *) 0 ;
23767   unsigned int result;
23768
23769   arg1 = (Dali::Image *)jarg1;
23770   {
23771     try {
23772       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23773     } catch (std::out_of_range& e) {
23774       {
23775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23776       };
23777     } catch (std::exception& e) {
23778       {
23779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (Dali::DaliException e) {
23782       {
23783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23784       };
23785     } catch (...) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23788       };
23789     }
23790   }
23791
23792   jresult = result;
23793   return jresult;
23794 }
23795
23796
23797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23798   void * jresult ;
23799   Dali::Image *arg1 = (Dali::Image *) 0 ;
23800   Dali::Image::ImageSignalType *result = 0 ;
23801
23802   arg1 = (Dali::Image *)jarg1;
23803   {
23804     try {
23805       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23806     } catch (std::out_of_range& e) {
23807       {
23808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23809       };
23810     } catch (std::exception& e) {
23811       {
23812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (Dali::DaliException e) {
23815       {
23816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23817       };
23818     } catch (...) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23821       };
23822     }
23823   }
23824
23825   jresult = (void *)result;
23826   return jresult;
23827 }
23828
23829
23830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23831   int jresult ;
23832   Dali::Pixel::Format result;
23833
23834   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23835   jresult = (int)result;
23836   return jresult;
23837 }
23838
23839
23840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23841   int jresult ;
23842   Dali::Pixel::Format result;
23843
23844   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23845   jresult = (int)result;
23846   return jresult;
23847 }
23848
23849
23850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23851   unsigned int jresult ;
23852   Dali::Pixel::Format arg1 ;
23853   bool result;
23854
23855   arg1 = (Dali::Pixel::Format)jarg1;
23856   {
23857     try {
23858       result = (bool)Dali::Pixel::HasAlpha(arg1);
23859     } catch (std::out_of_range& e) {
23860       {
23861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23862       };
23863     } catch (std::exception& e) {
23864       {
23865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (Dali::DaliException e) {
23868       {
23869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23870       };
23871     } catch (...) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23874       };
23875     }
23876   }
23877
23878   jresult = result;
23879   return jresult;
23880 }
23881
23882
23883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23884   unsigned int jresult ;
23885   Dali::Pixel::Format arg1 ;
23886   unsigned int result;
23887
23888   arg1 = (Dali::Pixel::Format)jarg1;
23889   {
23890     try {
23891       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23892     } catch (std::out_of_range& e) {
23893       {
23894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23895       };
23896     } catch (std::exception& e) {
23897       {
23898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (Dali::DaliException e) {
23901       {
23902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23903       };
23904     } catch (...) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23907       };
23908     }
23909   }
23910
23911   jresult = result;
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23917   Dali::Pixel::Format arg1 ;
23918   int *arg2 = 0 ;
23919   int *arg3 = 0 ;
23920
23921   arg1 = (Dali::Pixel::Format)jarg1;
23922   arg2 = (int *)jarg2;
23923   if (!arg2) {
23924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23925     return ;
23926   }
23927   arg3 = (int *)jarg3;
23928   if (!arg3) {
23929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23930     return ;
23931   }
23932   {
23933     try {
23934       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23935     } catch (std::out_of_range& e) {
23936       {
23937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23938       };
23939     } catch (std::exception& e) {
23940       {
23941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (Dali::DaliException e) {
23944       {
23945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23950       };
23951     }
23952   }
23953
23954 }
23955
23956
23957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23958   void * jresult ;
23959   unsigned char *arg1 = (unsigned char *) 0 ;
23960   unsigned int arg2 ;
23961   unsigned int arg3 ;
23962   unsigned int arg4 ;
23963   Dali::Pixel::Format arg5 ;
23964   Dali::PixelData::ReleaseFunction arg6 ;
23965   Dali::PixelData result;
23966
23967   arg1 = jarg1;
23968   arg2 = (unsigned int)jarg2;
23969   arg3 = (unsigned int)jarg3;
23970   arg4 = (unsigned int)jarg4;
23971   arg5 = (Dali::Pixel::Format)jarg5;
23972   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23973   {
23974     try {
23975       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23976     } catch (std::out_of_range& e) {
23977       {
23978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23979       };
23980     } catch (std::exception& e) {
23981       {
23982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (Dali::DaliException e) {
23985       {
23986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23987       };
23988     } catch (...) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23991       };
23992     }
23993   }
23994
23995   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23996
23997
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24003   void * jresult ;
24004   Dali::PixelData *result = 0 ;
24005
24006   {
24007     try {
24008       result = (Dali::PixelData *)new Dali::PixelData();
24009     } catch (std::out_of_range& e) {
24010       {
24011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24012       };
24013     } catch (std::exception& e) {
24014       {
24015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (Dali::DaliException e) {
24018       {
24019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24020       };
24021     } catch (...) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24024       };
24025     }
24026   }
24027
24028   jresult = (void *)result;
24029   return jresult;
24030 }
24031
24032
24033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24034   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24035
24036   arg1 = (Dali::PixelData *)jarg1;
24037   {
24038     try {
24039       delete arg1;
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24047       };
24048     } catch (Dali::DaliException e) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24051       };
24052     } catch (...) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24055       };
24056     }
24057   }
24058
24059 }
24060
24061
24062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24063   void * jresult ;
24064   Dali::PixelData *arg1 = 0 ;
24065   Dali::PixelData *result = 0 ;
24066
24067   arg1 = (Dali::PixelData *)jarg1;
24068   if (!arg1) {
24069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24070     return 0;
24071   }
24072   {
24073     try {
24074       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24075     } catch (std::out_of_range& e) {
24076       {
24077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24078       };
24079     } catch (std::exception& e) {
24080       {
24081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24082       };
24083     } catch (Dali::DaliException e) {
24084       {
24085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24086       };
24087     } catch (...) {
24088       {
24089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24090       };
24091     }
24092   }
24093
24094   jresult = (void *)result;
24095   return jresult;
24096 }
24097
24098
24099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24100   void * jresult ;
24101   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24102   Dali::PixelData *arg2 = 0 ;
24103   Dali::PixelData *result = 0 ;
24104
24105   arg1 = (Dali::PixelData *)jarg1;
24106   arg2 = (Dali::PixelData *)jarg2;
24107   if (!arg2) {
24108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24109     return 0;
24110   }
24111   {
24112     try {
24113       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24114     } catch (std::out_of_range& e) {
24115       {
24116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24117       };
24118     } catch (std::exception& e) {
24119       {
24120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24121       };
24122     } catch (Dali::DaliException e) {
24123       {
24124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24125       };
24126     } catch (...) {
24127       {
24128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24129       };
24130     }
24131   }
24132
24133   jresult = (void *)result;
24134   return jresult;
24135 }
24136
24137
24138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24139   unsigned int jresult ;
24140   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24141   unsigned int result;
24142
24143   arg1 = (Dali::PixelData *)jarg1;
24144   {
24145     try {
24146       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24147     } catch (std::out_of_range& e) {
24148       {
24149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24150       };
24151     } catch (std::exception& e) {
24152       {
24153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (Dali::DaliException e) {
24156       {
24157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24158       };
24159     } catch (...) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24162       };
24163     }
24164   }
24165
24166   jresult = result;
24167   return jresult;
24168 }
24169
24170
24171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24172   unsigned int jresult ;
24173   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24174   unsigned int result;
24175
24176   arg1 = (Dali::PixelData *)jarg1;
24177   {
24178     try {
24179       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24180     } catch (std::out_of_range& e) {
24181       {
24182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24183       };
24184     } catch (std::exception& e) {
24185       {
24186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (Dali::DaliException e) {
24189       {
24190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24191       };
24192     } catch (...) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24195       };
24196     }
24197   }
24198
24199   jresult = result;
24200   return jresult;
24201 }
24202
24203
24204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24205   int jresult ;
24206   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24207   Dali::Pixel::Format result;
24208
24209   arg1 = (Dali::PixelData *)jarg1;
24210   {
24211     try {
24212       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24213     } catch (std::out_of_range& e) {
24214       {
24215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24216       };
24217     } catch (std::exception& e) {
24218       {
24219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (Dali::DaliException e) {
24222       {
24223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24224       };
24225     } catch (...) {
24226       {
24227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24228       };
24229     }
24230   }
24231
24232   jresult = (int)result;
24233   return jresult;
24234 }
24235
24236
24237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24238   unsigned int jresult ;
24239   unsigned int result;
24240
24241   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24242   jresult = result;
24243   return jresult;
24244 }
24245
24246
24247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24248   unsigned int jresult ;
24249   unsigned int result;
24250
24251   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24252   jresult = result;
24253   return jresult;
24254 }
24255
24256
24257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24258   unsigned int jresult ;
24259   unsigned int result;
24260
24261   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24262   jresult = result;
24263   return jresult;
24264 }
24265
24266
24267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24268   unsigned int jresult ;
24269   unsigned int result;
24270
24271   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24272   jresult = result;
24273   return jresult;
24274 }
24275
24276
24277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24278   unsigned int jresult ;
24279   unsigned int result;
24280
24281   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24282   jresult = result;
24283   return jresult;
24284 }
24285
24286
24287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24288   unsigned int jresult ;
24289   unsigned int result;
24290
24291   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24292   jresult = result;
24293   return jresult;
24294 }
24295
24296
24297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24298   void * jresult ;
24299   Dali::TextureType::Type arg1 ;
24300   Dali::Pixel::Format arg2 ;
24301   unsigned int arg3 ;
24302   unsigned int arg4 ;
24303   Dali::Texture result;
24304
24305   arg1 = (Dali::TextureType::Type)jarg1;
24306   arg2 = (Dali::Pixel::Format)jarg2;
24307   arg3 = (unsigned int)jarg3;
24308   arg4 = (unsigned int)jarg4;
24309   {
24310     try {
24311       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24312     } catch (std::out_of_range& e) {
24313       {
24314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24315       };
24316     } catch (std::exception& e) {
24317       {
24318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (Dali::DaliException e) {
24321       {
24322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24323       };
24324     } catch (...) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24327       };
24328     }
24329   }
24330
24331   jresult = new Dali::Texture((const Dali::Texture &)result);
24332   return jresult;
24333 }
24334
24335
24336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24337   void * jresult ;
24338   NativeImageInterface *arg1 = 0 ;
24339   Dali::Texture result;
24340
24341   arg1 = (NativeImageInterface *)jarg1;
24342   if (!arg1) {
24343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24344     return 0;
24345   }
24346   {
24347     try {
24348       result = Dali::Texture::New(*arg1);
24349     } catch (std::out_of_range& e) {
24350       {
24351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24352       };
24353     } catch (std::exception& e) {
24354       {
24355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (Dali::DaliException e) {
24358       {
24359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24360       };
24361     } catch (...) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24364       };
24365     }
24366   }
24367
24368   jresult = new Dali::Texture((const Dali::Texture &)result);
24369   return jresult;
24370 }
24371
24372
24373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24374   void * jresult ;
24375   Dali::Texture *result = 0 ;
24376
24377   {
24378     try {
24379       result = (Dali::Texture *)new Dali::Texture();
24380     } catch (std::out_of_range& e) {
24381       {
24382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24383       };
24384     } catch (std::exception& e) {
24385       {
24386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (Dali::DaliException e) {
24389       {
24390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24391       };
24392     } catch (...) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24395       };
24396     }
24397   }
24398
24399   jresult = (void *)result;
24400   return jresult;
24401 }
24402
24403
24404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24405   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24406
24407   arg1 = (Dali::Texture *)jarg1;
24408   {
24409     try {
24410       delete arg1;
24411     } catch (std::out_of_range& e) {
24412       {
24413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24414       };
24415     } catch (std::exception& e) {
24416       {
24417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24418       };
24419     } catch (Dali::DaliException e) {
24420       {
24421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24422       };
24423     } catch (...) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24426       };
24427     }
24428   }
24429
24430 }
24431
24432
24433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24434   void * jresult ;
24435   Dali::Texture *arg1 = 0 ;
24436   Dali::Texture *result = 0 ;
24437
24438   arg1 = (Dali::Texture *)jarg1;
24439   if (!arg1) {
24440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24441     return 0;
24442   }
24443   {
24444     try {
24445       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24446     } catch (std::out_of_range& e) {
24447       {
24448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24449       };
24450     } catch (std::exception& e) {
24451       {
24452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24453       };
24454     } catch (Dali::DaliException e) {
24455       {
24456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24457       };
24458     } catch (...) {
24459       {
24460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24461       };
24462     }
24463   }
24464
24465   jresult = (void *)result;
24466   return jresult;
24467 }
24468
24469
24470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24471   void * jresult ;
24472   Dali::BaseHandle arg1 ;
24473   Dali::BaseHandle *argp1 ;
24474   Dali::Texture result;
24475
24476   argp1 = (Dali::BaseHandle *)jarg1;
24477   if (!argp1) {
24478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24479     return 0;
24480   }
24481   arg1 = *argp1;
24482   {
24483     try {
24484       result = Dali::Texture::DownCast(arg1);
24485     } catch (std::out_of_range& e) {
24486       {
24487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (std::exception& e) {
24490       {
24491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24492       };
24493     } catch (Dali::DaliException e) {
24494       {
24495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24496       };
24497     } catch (...) {
24498       {
24499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24500       };
24501     }
24502   }
24503
24504   jresult = new Dali::Texture((const Dali::Texture &)result);
24505   return jresult;
24506 }
24507
24508
24509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24510   void * jresult ;
24511   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24512   Dali::Texture *arg2 = 0 ;
24513   Dali::Texture *result = 0 ;
24514
24515   arg1 = (Dali::Texture *)jarg1;
24516   arg2 = (Dali::Texture *)jarg2;
24517   if (!arg2) {
24518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24519     return 0;
24520   }
24521   {
24522     try {
24523       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24524     } catch (std::out_of_range& e) {
24525       {
24526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (std::exception& e) {
24529       {
24530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (Dali::DaliException e) {
24533       {
24534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24535       };
24536     } catch (...) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24539       };
24540     }
24541   }
24542
24543   jresult = (void *)result;
24544   return jresult;
24545 }
24546
24547
24548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24549   unsigned int jresult ;
24550   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24551   Dali::PixelData arg2 ;
24552   Dali::PixelData *argp2 ;
24553   bool result;
24554
24555   arg1 = (Dali::Texture *)jarg1;
24556   argp2 = (Dali::PixelData *)jarg2;
24557   if (!argp2) {
24558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24559     return 0;
24560   }
24561   arg2 = *argp2;
24562   {
24563     try {
24564       result = (bool)(arg1)->Upload(arg2);
24565     } catch (std::out_of_range& e) {
24566       {
24567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24568       };
24569     } catch (std::exception& e) {
24570       {
24571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (Dali::DaliException e) {
24574       {
24575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24576       };
24577     } catch (...) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24580       };
24581     }
24582   }
24583
24584   jresult = result;
24585   return jresult;
24586 }
24587
24588
24589 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) {
24590   unsigned int jresult ;
24591   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24592   Dali::PixelData arg2 ;
24593   unsigned int arg3 ;
24594   unsigned int arg4 ;
24595   unsigned int arg5 ;
24596   unsigned int arg6 ;
24597   unsigned int arg7 ;
24598   unsigned int arg8 ;
24599   Dali::PixelData *argp2 ;
24600   bool result;
24601
24602   arg1 = (Dali::Texture *)jarg1;
24603   argp2 = (Dali::PixelData *)jarg2;
24604   if (!argp2) {
24605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24606     return 0;
24607   }
24608   arg2 = *argp2;
24609   arg3 = (unsigned int)jarg3;
24610   arg4 = (unsigned int)jarg4;
24611   arg5 = (unsigned int)jarg5;
24612   arg6 = (unsigned int)jarg6;
24613   arg7 = (unsigned int)jarg7;
24614   arg8 = (unsigned int)jarg8;
24615   {
24616     try {
24617       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24618     } catch (std::out_of_range& e) {
24619       {
24620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24621       };
24622     } catch (std::exception& e) {
24623       {
24624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (Dali::DaliException e) {
24627       {
24628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24629       };
24630     } catch (...) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24633       };
24634     }
24635   }
24636
24637   jresult = result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24643   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24644
24645   arg1 = (Dali::Texture *)jarg1;
24646   {
24647     try {
24648       (arg1)->GenerateMipmaps();
24649     } catch (std::out_of_range& e) {
24650       {
24651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24652       };
24653     } catch (std::exception& e) {
24654       {
24655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24656       };
24657     } catch (Dali::DaliException e) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24660       };
24661     } catch (...) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24664       };
24665     }
24666   }
24667
24668 }
24669
24670
24671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24672   unsigned int jresult ;
24673   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24674   unsigned int result;
24675
24676   arg1 = (Dali::Texture *)jarg1;
24677   {
24678     try {
24679       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24680     } catch (std::out_of_range& e) {
24681       {
24682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24683       };
24684     } catch (std::exception& e) {
24685       {
24686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24687       };
24688     } catch (Dali::DaliException e) {
24689       {
24690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24691       };
24692     } catch (...) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24695       };
24696     }
24697   }
24698
24699   jresult = result;
24700   return jresult;
24701 }
24702
24703
24704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24705   unsigned int jresult ;
24706   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24707   unsigned int result;
24708
24709   arg1 = (Dali::Texture *)jarg1;
24710   {
24711     try {
24712       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24713     } catch (std::out_of_range& e) {
24714       {
24715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24716       };
24717     } catch (std::exception& e) {
24718       {
24719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24720       };
24721     } catch (Dali::DaliException e) {
24722       {
24723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24724       };
24725     } catch (...) {
24726       {
24727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24728       };
24729     }
24730   }
24731
24732   jresult = result;
24733   return jresult;
24734 }
24735
24736
24737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24738   void * jresult ;
24739   Dali::Sampler result;
24740
24741   {
24742     try {
24743       result = Dali::Sampler::New();
24744     } catch (std::out_of_range& e) {
24745       {
24746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24747       };
24748     } catch (std::exception& e) {
24749       {
24750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (Dali::DaliException e) {
24753       {
24754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24755       };
24756     } catch (...) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24759       };
24760     }
24761   }
24762
24763   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24769   void * jresult ;
24770   Dali::Sampler *result = 0 ;
24771
24772   {
24773     try {
24774       result = (Dali::Sampler *)new Dali::Sampler();
24775     } catch (std::out_of_range& e) {
24776       {
24777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24778       };
24779     } catch (std::exception& e) {
24780       {
24781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (Dali::DaliException e) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24786       };
24787     } catch (...) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24790       };
24791     }
24792   }
24793
24794   jresult = (void *)result;
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24800   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24801
24802   arg1 = (Dali::Sampler *)jarg1;
24803   {
24804     try {
24805       delete arg1;
24806     } catch (std::out_of_range& e) {
24807       {
24808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24809       };
24810     } catch (std::exception& e) {
24811       {
24812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (Dali::DaliException e) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24817       };
24818     } catch (...) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24821       };
24822     }
24823   }
24824
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24829   void * jresult ;
24830   Dali::Sampler *arg1 = 0 ;
24831   Dali::Sampler *result = 0 ;
24832
24833   arg1 = (Dali::Sampler *)jarg1;
24834   if (!arg1) {
24835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24836     return 0;
24837   }
24838   {
24839     try {
24840       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24841     } catch (std::out_of_range& e) {
24842       {
24843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24844       };
24845     } catch (std::exception& e) {
24846       {
24847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24848       };
24849     } catch (Dali::DaliException e) {
24850       {
24851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24852       };
24853     } catch (...) {
24854       {
24855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24856       };
24857     }
24858   }
24859
24860   jresult = (void *)result;
24861   return jresult;
24862 }
24863
24864
24865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24866   void * jresult ;
24867   Dali::BaseHandle arg1 ;
24868   Dali::BaseHandle *argp1 ;
24869   Dali::Sampler result;
24870
24871   argp1 = (Dali::BaseHandle *)jarg1;
24872   if (!argp1) {
24873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24874     return 0;
24875   }
24876   arg1 = *argp1;
24877   {
24878     try {
24879       result = Dali::Sampler::DownCast(arg1);
24880     } catch (std::out_of_range& e) {
24881       {
24882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24883       };
24884     } catch (std::exception& e) {
24885       {
24886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24887       };
24888     } catch (Dali::DaliException e) {
24889       {
24890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24891       };
24892     } catch (...) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24895       };
24896     }
24897   }
24898
24899   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24900   return jresult;
24901 }
24902
24903
24904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24905   void * jresult ;
24906   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24907   Dali::Sampler *arg2 = 0 ;
24908   Dali::Sampler *result = 0 ;
24909
24910   arg1 = (Dali::Sampler *)jarg1;
24911   arg2 = (Dali::Sampler *)jarg2;
24912   if (!arg2) {
24913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24914     return 0;
24915   }
24916   {
24917     try {
24918       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (Dali::DaliException e) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24930       };
24931     } catch (...) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24934       };
24935     }
24936   }
24937
24938   jresult = (void *)result;
24939   return jresult;
24940 }
24941
24942
24943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24944   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24945   Dali::FilterMode::Type arg2 ;
24946   Dali::FilterMode::Type arg3 ;
24947
24948   arg1 = (Dali::Sampler *)jarg1;
24949   arg2 = (Dali::FilterMode::Type)jarg2;
24950   arg3 = (Dali::FilterMode::Type)jarg3;
24951   {
24952     try {
24953       (arg1)->SetFilterMode(arg2,arg3);
24954     } catch (std::out_of_range& e) {
24955       {
24956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24957       };
24958     } catch (std::exception& e) {
24959       {
24960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (Dali::DaliException e) {
24963       {
24964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24965       };
24966     } catch (...) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24969       };
24970     }
24971   }
24972
24973 }
24974
24975
24976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24977   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24978   Dali::WrapMode::Type arg2 ;
24979   Dali::WrapMode::Type arg3 ;
24980
24981   arg1 = (Dali::Sampler *)jarg1;
24982   arg2 = (Dali::WrapMode::Type)jarg2;
24983   arg3 = (Dali::WrapMode::Type)jarg3;
24984   {
24985     try {
24986       (arg1)->SetWrapMode(arg2,arg3);
24987     } catch (std::out_of_range& e) {
24988       {
24989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24990       };
24991     } catch (std::exception& e) {
24992       {
24993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (Dali::DaliException e) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24998       };
24999     } catch (...) {
25000       {
25001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25002       };
25003     }
25004   }
25005
25006 }
25007
25008
25009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25010   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25011   Dali::WrapMode::Type arg2 ;
25012   Dali::WrapMode::Type arg3 ;
25013   Dali::WrapMode::Type arg4 ;
25014
25015   arg1 = (Dali::Sampler *)jarg1;
25016   arg2 = (Dali::WrapMode::Type)jarg2;
25017   arg3 = (Dali::WrapMode::Type)jarg3;
25018   arg4 = (Dali::WrapMode::Type)jarg4;
25019   {
25020     try {
25021       (arg1)->SetWrapMode(arg2,arg3,arg4);
25022     } catch (std::out_of_range& e) {
25023       {
25024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (std::exception& e) {
25027       {
25028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25029       };
25030     } catch (Dali::DaliException e) {
25031       {
25032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25033       };
25034     } catch (...) {
25035       {
25036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25037       };
25038     }
25039   }
25040
25041 }
25042
25043
25044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25045   void * jresult ;
25046   Dali::TextureSet result;
25047
25048   {
25049     try {
25050       result = Dali::TextureSet::New();
25051     } catch (std::out_of_range& e) {
25052       {
25053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25054       };
25055     } catch (std::exception& e) {
25056       {
25057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25058       };
25059     } catch (Dali::DaliException e) {
25060       {
25061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25066       };
25067     }
25068   }
25069
25070   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25071   return jresult;
25072 }
25073
25074
25075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25076   void * jresult ;
25077   Dali::TextureSet *result = 0 ;
25078
25079   {
25080     try {
25081       result = (Dali::TextureSet *)new Dali::TextureSet();
25082     } catch (std::out_of_range& e) {
25083       {
25084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25085       };
25086     } catch (std::exception& e) {
25087       {
25088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25089       };
25090     } catch (Dali::DaliException e) {
25091       {
25092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25093       };
25094     } catch (...) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25097       };
25098     }
25099   }
25100
25101   jresult = (void *)result;
25102   return jresult;
25103 }
25104
25105
25106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25107   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25108
25109   arg1 = (Dali::TextureSet *)jarg1;
25110   {
25111     try {
25112       delete arg1;
25113     } catch (std::out_of_range& e) {
25114       {
25115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25116       };
25117     } catch (std::exception& e) {
25118       {
25119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (Dali::DaliException e) {
25122       {
25123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25124       };
25125     } catch (...) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25128       };
25129     }
25130   }
25131
25132 }
25133
25134
25135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25136   void * jresult ;
25137   Dali::TextureSet *arg1 = 0 ;
25138   Dali::TextureSet *result = 0 ;
25139
25140   arg1 = (Dali::TextureSet *)jarg1;
25141   if (!arg1) {
25142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25143     return 0;
25144   }
25145   {
25146     try {
25147       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25148     } catch (std::out_of_range& e) {
25149       {
25150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25151       };
25152     } catch (std::exception& e) {
25153       {
25154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25155       };
25156     } catch (Dali::DaliException e) {
25157       {
25158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25159       };
25160     } catch (...) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25163       };
25164     }
25165   }
25166
25167   jresult = (void *)result;
25168   return jresult;
25169 }
25170
25171
25172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25173   void * jresult ;
25174   Dali::BaseHandle arg1 ;
25175   Dali::BaseHandle *argp1 ;
25176   Dali::TextureSet result;
25177
25178   argp1 = (Dali::BaseHandle *)jarg1;
25179   if (!argp1) {
25180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25181     return 0;
25182   }
25183   arg1 = *argp1;
25184   {
25185     try {
25186       result = Dali::TextureSet::DownCast(arg1);
25187     } catch (std::out_of_range& e) {
25188       {
25189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25190       };
25191     } catch (std::exception& e) {
25192       {
25193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25194       };
25195     } catch (Dali::DaliException e) {
25196       {
25197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25198       };
25199     } catch (...) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25202       };
25203     }
25204   }
25205
25206   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25207   return jresult;
25208 }
25209
25210
25211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25212   void * jresult ;
25213   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25214   Dali::TextureSet *arg2 = 0 ;
25215   Dali::TextureSet *result = 0 ;
25216
25217   arg1 = (Dali::TextureSet *)jarg1;
25218   arg2 = (Dali::TextureSet *)jarg2;
25219   if (!arg2) {
25220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25221     return 0;
25222   }
25223   {
25224     try {
25225       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25226     } catch (std::out_of_range& e) {
25227       {
25228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25229       };
25230     } catch (std::exception& e) {
25231       {
25232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (Dali::DaliException e) {
25235       {
25236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25237       };
25238     } catch (...) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25241       };
25242     }
25243   }
25244
25245   jresult = (void *)result;
25246   return jresult;
25247 }
25248
25249
25250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25251   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25252   size_t arg2 ;
25253   Dali::Texture arg3 ;
25254   Dali::Texture *argp3 ;
25255
25256   arg1 = (Dali::TextureSet *)jarg1;
25257   arg2 = (size_t)jarg2;
25258   argp3 = (Dali::Texture *)jarg3;
25259   if (!argp3) {
25260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25261     return ;
25262   }
25263   arg3 = *argp3;
25264   {
25265     try {
25266       (arg1)->SetTexture(arg2,arg3);
25267     } catch (std::out_of_range& e) {
25268       {
25269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25270       };
25271     } catch (std::exception& e) {
25272       {
25273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25274       };
25275     } catch (Dali::DaliException e) {
25276       {
25277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25278       };
25279     } catch (...) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25282       };
25283     }
25284   }
25285
25286 }
25287
25288
25289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25290   void * jresult ;
25291   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25292   size_t arg2 ;
25293   Dali::Texture result;
25294
25295   arg1 = (Dali::TextureSet *)jarg1;
25296   arg2 = (size_t)jarg2;
25297   {
25298     try {
25299       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25300     } catch (std::out_of_range& e) {
25301       {
25302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25303       };
25304     } catch (std::exception& e) {
25305       {
25306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (Dali::DaliException e) {
25309       {
25310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25311       };
25312     } catch (...) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25315       };
25316     }
25317   }
25318
25319   jresult = new Dali::Texture((const Dali::Texture &)result);
25320   return jresult;
25321 }
25322
25323
25324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25325   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25326   size_t arg2 ;
25327   Dali::Sampler arg3 ;
25328   Dali::Sampler *argp3 ;
25329
25330   arg1 = (Dali::TextureSet *)jarg1;
25331   arg2 = (size_t)jarg2;
25332   argp3 = (Dali::Sampler *)jarg3;
25333   if (!argp3) {
25334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25335     return ;
25336   }
25337   arg3 = *argp3;
25338   {
25339     try {
25340       (arg1)->SetSampler(arg2,arg3);
25341     } catch (std::out_of_range& e) {
25342       {
25343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25344       };
25345     } catch (std::exception& e) {
25346       {
25347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25348       };
25349     } catch (Dali::DaliException e) {
25350       {
25351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25352       };
25353     } catch (...) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25356       };
25357     }
25358   }
25359
25360 }
25361
25362
25363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25364   void * jresult ;
25365   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25366   size_t arg2 ;
25367   Dali::Sampler result;
25368
25369   arg1 = (Dali::TextureSet *)jarg1;
25370   arg2 = (size_t)jarg2;
25371   {
25372     try {
25373       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25374     } catch (std::out_of_range& e) {
25375       {
25376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25377       };
25378     } catch (std::exception& e) {
25379       {
25380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (Dali::DaliException e) {
25383       {
25384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25385       };
25386     } catch (...) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25389       };
25390     }
25391   }
25392
25393   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25394   return jresult;
25395 }
25396
25397
25398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25399   unsigned long jresult ;
25400   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25401   size_t result;
25402
25403   arg1 = (Dali::TextureSet *)jarg1;
25404   {
25405     try {
25406       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25422       };
25423     }
25424   }
25425
25426   jresult = (unsigned long)result;
25427   return jresult;
25428 }
25429
25430
25431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25432   void * jresult ;
25433   Dali::Property::Map *arg1 = 0 ;
25434   Dali::PropertyBuffer result;
25435
25436   arg1 = (Dali::Property::Map *)jarg1;
25437   if (!arg1) {
25438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25439     return 0;
25440   }
25441   {
25442     try {
25443       result = Dali::PropertyBuffer::New(*arg1);
25444     } catch (std::out_of_range& e) {
25445       {
25446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25447       };
25448     } catch (std::exception& e) {
25449       {
25450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25451       };
25452     } catch (Dali::DaliException e) {
25453       {
25454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25455       };
25456     } catch (...) {
25457       {
25458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25459       };
25460     }
25461   }
25462
25463   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25464   return jresult;
25465 }
25466
25467
25468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25469   void * jresult ;
25470   Dali::PropertyBuffer *result = 0 ;
25471
25472   {
25473     try {
25474       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25475     } catch (std::out_of_range& e) {
25476       {
25477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (std::exception& e) {
25480       {
25481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (Dali::DaliException e) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25486       };
25487     } catch (...) {
25488       {
25489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25490       };
25491     }
25492   }
25493
25494   jresult = (void *)result;
25495   return jresult;
25496 }
25497
25498
25499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25500   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25501
25502   arg1 = (Dali::PropertyBuffer *)jarg1;
25503   {
25504     try {
25505       delete arg1;
25506     } catch (std::out_of_range& e) {
25507       {
25508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25509       };
25510     } catch (std::exception& e) {
25511       {
25512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25513       };
25514     } catch (Dali::DaliException e) {
25515       {
25516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25517       };
25518     } catch (...) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25521       };
25522     }
25523   }
25524
25525 }
25526
25527
25528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25529   void * jresult ;
25530   Dali::PropertyBuffer *arg1 = 0 ;
25531   Dali::PropertyBuffer *result = 0 ;
25532
25533   arg1 = (Dali::PropertyBuffer *)jarg1;
25534   if (!arg1) {
25535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25536     return 0;
25537   }
25538   {
25539     try {
25540       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25541     } catch (std::out_of_range& e) {
25542       {
25543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25544       };
25545     } catch (std::exception& e) {
25546       {
25547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25548       };
25549     } catch (Dali::DaliException e) {
25550       {
25551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25552       };
25553     } catch (...) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25556       };
25557     }
25558   }
25559
25560   jresult = (void *)result;
25561   return jresult;
25562 }
25563
25564
25565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25566   void * jresult ;
25567   Dali::BaseHandle arg1 ;
25568   Dali::BaseHandle *argp1 ;
25569   Dali::PropertyBuffer result;
25570
25571   argp1 = (Dali::BaseHandle *)jarg1;
25572   if (!argp1) {
25573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25574     return 0;
25575   }
25576   arg1 = *argp1;
25577   {
25578     try {
25579       result = Dali::PropertyBuffer::DownCast(arg1);
25580     } catch (std::out_of_range& e) {
25581       {
25582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25583       };
25584     } catch (std::exception& e) {
25585       {
25586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25587       };
25588     } catch (Dali::DaliException e) {
25589       {
25590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25591       };
25592     } catch (...) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25595       };
25596     }
25597   }
25598
25599   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25600   return jresult;
25601 }
25602
25603
25604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25605   void * jresult ;
25606   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25607   Dali::PropertyBuffer *arg2 = 0 ;
25608   Dali::PropertyBuffer *result = 0 ;
25609
25610   arg1 = (Dali::PropertyBuffer *)jarg1;
25611   arg2 = (Dali::PropertyBuffer *)jarg2;
25612   if (!arg2) {
25613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25614     return 0;
25615   }
25616   {
25617     try {
25618       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25619     } catch (std::out_of_range& e) {
25620       {
25621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25622       };
25623     } catch (std::exception& e) {
25624       {
25625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (Dali::DaliException e) {
25628       {
25629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25630       };
25631     } catch (...) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25634       };
25635     }
25636   }
25637
25638   jresult = (void *)result;
25639   return jresult;
25640 }
25641
25642
25643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25644   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25645   void *arg2 = (void *) 0 ;
25646   std::size_t arg3 ;
25647
25648   arg1 = (Dali::PropertyBuffer *)jarg1;
25649   arg2 = jarg2;
25650   arg3 = (std::size_t)jarg3;
25651   {
25652     try {
25653       (arg1)->SetData((void const *)arg2,arg3);
25654     } catch (std::out_of_range& e) {
25655       {
25656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25657       };
25658     } catch (std::exception& e) {
25659       {
25660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (Dali::DaliException e) {
25663       {
25664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25665       };
25666     } catch (...) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25669       };
25670     }
25671   }
25672
25673 }
25674
25675
25676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25677   unsigned long jresult ;
25678   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25679   std::size_t result;
25680
25681   arg1 = (Dali::PropertyBuffer *)jarg1;
25682   {
25683     try {
25684       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25685     } catch (std::out_of_range& e) {
25686       {
25687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25688       };
25689     } catch (std::exception& e) {
25690       {
25691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (Dali::DaliException e) {
25694       {
25695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25696       };
25697     } catch (...) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25700       };
25701     }
25702   }
25703
25704   jresult = (unsigned long)result;
25705   return jresult;
25706 }
25707
25708
25709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25710   void * jresult ;
25711   Dali::Geometry result;
25712
25713   {
25714     try {
25715       result = Dali::Geometry::New();
25716     } catch (std::out_of_range& e) {
25717       {
25718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25719       };
25720     } catch (std::exception& e) {
25721       {
25722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (Dali::DaliException e) {
25725       {
25726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25727       };
25728     } catch (...) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25731       };
25732     }
25733   }
25734
25735   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25736   return jresult;
25737 }
25738
25739
25740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25741   void * jresult ;
25742   Dali::Geometry *result = 0 ;
25743
25744   {
25745     try {
25746       result = (Dali::Geometry *)new Dali::Geometry();
25747     } catch (std::out_of_range& e) {
25748       {
25749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25750       };
25751     } catch (std::exception& e) {
25752       {
25753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (Dali::DaliException e) {
25756       {
25757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25758       };
25759     } catch (...) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25762       };
25763     }
25764   }
25765
25766   jresult = (void *)result;
25767   return jresult;
25768 }
25769
25770
25771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25772   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25773
25774   arg1 = (Dali::Geometry *)jarg1;
25775   {
25776     try {
25777       delete arg1;
25778     } catch (std::out_of_range& e) {
25779       {
25780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25781       };
25782     } catch (std::exception& e) {
25783       {
25784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (Dali::DaliException e) {
25787       {
25788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25789       };
25790     } catch (...) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25793       };
25794     }
25795   }
25796
25797 }
25798
25799
25800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25801   void * jresult ;
25802   Dali::Geometry *arg1 = 0 ;
25803   Dali::Geometry *result = 0 ;
25804
25805   arg1 = (Dali::Geometry *)jarg1;
25806   if (!arg1) {
25807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25808     return 0;
25809   }
25810   {
25811     try {
25812       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25813     } catch (std::out_of_range& e) {
25814       {
25815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25816       };
25817     } catch (std::exception& e) {
25818       {
25819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (Dali::DaliException e) {
25822       {
25823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25824       };
25825     } catch (...) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25828       };
25829     }
25830   }
25831
25832   jresult = (void *)result;
25833   return jresult;
25834 }
25835
25836
25837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25838   void * jresult ;
25839   Dali::BaseHandle arg1 ;
25840   Dali::BaseHandle *argp1 ;
25841   Dali::Geometry result;
25842
25843   argp1 = (Dali::BaseHandle *)jarg1;
25844   if (!argp1) {
25845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25846     return 0;
25847   }
25848   arg1 = *argp1;
25849   {
25850     try {
25851       result = Dali::Geometry::DownCast(arg1);
25852     } catch (std::out_of_range& e) {
25853       {
25854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25855       };
25856     } catch (std::exception& e) {
25857       {
25858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (Dali::DaliException e) {
25861       {
25862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25863       };
25864     } catch (...) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25867       };
25868     }
25869   }
25870
25871   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25872   return jresult;
25873 }
25874
25875
25876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25877   void * jresult ;
25878   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25879   Dali::Geometry *arg2 = 0 ;
25880   Dali::Geometry *result = 0 ;
25881
25882   arg1 = (Dali::Geometry *)jarg1;
25883   arg2 = (Dali::Geometry *)jarg2;
25884   if (!arg2) {
25885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25886     return 0;
25887   }
25888   {
25889     try {
25890       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25891     } catch (std::out_of_range& e) {
25892       {
25893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25894       };
25895     } catch (std::exception& e) {
25896       {
25897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (Dali::DaliException e) {
25900       {
25901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25902       };
25903     } catch (...) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25906       };
25907     }
25908   }
25909
25910   jresult = (void *)result;
25911   return jresult;
25912 }
25913
25914
25915 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25916   unsigned long jresult ;
25917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25918   Dali::PropertyBuffer *arg2 = 0 ;
25919   std::size_t result;
25920
25921   arg1 = (Dali::Geometry *)jarg1;
25922   arg2 = (Dali::PropertyBuffer *)jarg2;
25923   if (!arg2) {
25924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25925     return 0;
25926   }
25927   {
25928     try {
25929       result = (arg1)->AddVertexBuffer(*arg2);
25930     } catch (std::out_of_range& e) {
25931       {
25932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25933       };
25934     } catch (std::exception& e) {
25935       {
25936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (Dali::DaliException e) {
25939       {
25940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25941       };
25942     } catch (...) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25945       };
25946     }
25947   }
25948
25949   jresult = (unsigned long)result;
25950   return jresult;
25951 }
25952
25953
25954 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25955   unsigned long jresult ;
25956   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25957   std::size_t result;
25958
25959   arg1 = (Dali::Geometry *)jarg1;
25960   {
25961     try {
25962       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25963     } catch (std::out_of_range& e) {
25964       {
25965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25966       };
25967     } catch (std::exception& e) {
25968       {
25969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25970       };
25971     } catch (Dali::DaliException e) {
25972       {
25973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25974       };
25975     } catch (...) {
25976       {
25977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25978       };
25979     }
25980   }
25981
25982   jresult = (unsigned long)result;
25983   return jresult;
25984 }
25985
25986
25987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25988   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25989   std::size_t arg2 ;
25990
25991   arg1 = (Dali::Geometry *)jarg1;
25992   arg2 = (std::size_t)jarg2;
25993   {
25994     try {
25995       (arg1)->RemoveVertexBuffer(arg2);
25996     } catch (std::out_of_range& e) {
25997       {
25998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25999       };
26000     } catch (std::exception& e) {
26001       {
26002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (Dali::DaliException e) {
26005       {
26006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26007       };
26008     } catch (...) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26011       };
26012     }
26013   }
26014
26015 }
26016
26017
26018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26019   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26020   unsigned short *arg2 = (unsigned short *) 0 ;
26021   size_t arg3 ;
26022
26023   arg1 = (Dali::Geometry *)jarg1;
26024   arg2 = jarg2;
26025   arg3 = (size_t)jarg3;
26026   {
26027     try {
26028       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26029     } catch (std::out_of_range& e) {
26030       {
26031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26032       };
26033     } catch (std::exception& e) {
26034       {
26035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26036       };
26037     } catch (Dali::DaliException e) {
26038       {
26039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26040       };
26041     } catch (...) {
26042       {
26043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26044       };
26045     }
26046   }
26047
26048
26049
26050 }
26051
26052
26053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26054   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26055   Dali::Geometry::Type arg2 ;
26056
26057   arg1 = (Dali::Geometry *)jarg1;
26058   arg2 = (Dali::Geometry::Type)jarg2;
26059   {
26060     try {
26061       (arg1)->SetType(arg2);
26062     } catch (std::out_of_range& e) {
26063       {
26064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26065       };
26066     } catch (std::exception& e) {
26067       {
26068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26069       };
26070     } catch (Dali::DaliException e) {
26071       {
26072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26073       };
26074     } catch (...) {
26075       {
26076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26077       };
26078     }
26079   }
26080
26081 }
26082
26083
26084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26085   int jresult ;
26086   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26087   Dali::Geometry::Type result;
26088
26089   arg1 = (Dali::Geometry *)jarg1;
26090   {
26091     try {
26092       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26093     } catch (std::out_of_range& e) {
26094       {
26095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26096       };
26097     } catch (std::exception& e) {
26098       {
26099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26100       };
26101     } catch (Dali::DaliException e) {
26102       {
26103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26104       };
26105     } catch (...) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26108       };
26109     }
26110   }
26111
26112   jresult = (int)result;
26113   return jresult;
26114 }
26115
26116
26117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26118   void * jresult ;
26119   Dali::Shader::Hint *result = 0 ;
26120
26121   {
26122     try {
26123       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26124     } catch (std::out_of_range& e) {
26125       {
26126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26127       };
26128     } catch (std::exception& e) {
26129       {
26130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26131       };
26132     } catch (Dali::DaliException e) {
26133       {
26134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26135       };
26136     } catch (...) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26139       };
26140     }
26141   }
26142
26143   jresult = (void *)result;
26144   return jresult;
26145 }
26146
26147
26148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26149   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26150
26151   arg1 = (Dali::Shader::Hint *)jarg1;
26152   {
26153     try {
26154       delete arg1;
26155     } catch (std::out_of_range& e) {
26156       {
26157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26158       };
26159     } catch (std::exception& e) {
26160       {
26161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26162       };
26163     } catch (Dali::DaliException e) {
26164       {
26165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26166       };
26167     } catch (...) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26170       };
26171     }
26172   }
26173
26174 }
26175
26176
26177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26178   int jresult ;
26179   int result;
26180
26181   result = (int)Dali::Shader::Property::PROGRAM;
26182   jresult = (int)result;
26183   return jresult;
26184 }
26185
26186
26187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26188   void * jresult ;
26189   Dali::Shader::Property *result = 0 ;
26190
26191   {
26192     try {
26193       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26194     } catch (std::out_of_range& e) {
26195       {
26196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26197       };
26198     } catch (std::exception& e) {
26199       {
26200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26201       };
26202     } catch (Dali::DaliException e) {
26203       {
26204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26205       };
26206     } catch (...) {
26207       {
26208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26209       };
26210     }
26211   }
26212
26213   jresult = (void *)result;
26214   return jresult;
26215 }
26216
26217
26218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26219   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26220
26221   arg1 = (Dali::Shader::Property *)jarg1;
26222   {
26223     try {
26224       delete arg1;
26225     } catch (std::out_of_range& e) {
26226       {
26227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26228       };
26229     } catch (std::exception& e) {
26230       {
26231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26232       };
26233     } catch (Dali::DaliException e) {
26234       {
26235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26236       };
26237     } catch (...) {
26238       {
26239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26240       };
26241     }
26242   }
26243
26244 }
26245
26246
26247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26248   void * jresult ;
26249   std::string *arg1 = 0 ;
26250   std::string *arg2 = 0 ;
26251   Dali::Shader::Hint::Value arg3 ;
26252   Dali::Shader result;
26253
26254   if (!jarg1) {
26255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26256     return 0;
26257   }
26258   std::string arg1_str(jarg1);
26259   arg1 = &arg1_str;
26260   if (!jarg2) {
26261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26262     return 0;
26263   }
26264   std::string arg2_str(jarg2);
26265   arg2 = &arg2_str;
26266   arg3 = (Dali::Shader::Hint::Value)jarg3;
26267   {
26268     try {
26269       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26270     } catch (std::out_of_range& e) {
26271       {
26272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26273       };
26274     } catch (std::exception& e) {
26275       {
26276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (Dali::DaliException e) {
26279       {
26280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26281       };
26282     } catch (...) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26285       };
26286     }
26287   }
26288
26289   jresult = new Dali::Shader((const Dali::Shader &)result);
26290
26291   //argout typemap for const std::string&
26292
26293
26294   //argout typemap for const std::string&
26295
26296   return jresult;
26297 }
26298
26299
26300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26301   void * jresult ;
26302   std::string *arg1 = 0 ;
26303   std::string *arg2 = 0 ;
26304   Dali::Shader result;
26305
26306   if (!jarg1) {
26307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26308     return 0;
26309   }
26310   std::string arg1_str(jarg1);
26311   arg1 = &arg1_str;
26312   if (!jarg2) {
26313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26314     return 0;
26315   }
26316   std::string arg2_str(jarg2);
26317   arg2 = &arg2_str;
26318   {
26319     try {
26320       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26321     } catch (std::out_of_range& e) {
26322       {
26323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26324       };
26325     } catch (std::exception& e) {
26326       {
26327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (Dali::DaliException e) {
26330       {
26331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26332       };
26333     } catch (...) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26336       };
26337     }
26338   }
26339
26340   jresult = new Dali::Shader((const Dali::Shader &)result);
26341
26342   //argout typemap for const std::string&
26343
26344
26345   //argout typemap for const std::string&
26346
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26352   void * jresult ;
26353   Dali::Shader *result = 0 ;
26354
26355   {
26356     try {
26357       result = (Dali::Shader *)new Dali::Shader();
26358     } catch (std::out_of_range& e) {
26359       {
26360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26361       };
26362     } catch (std::exception& e) {
26363       {
26364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (Dali::DaliException e) {
26367       {
26368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26369       };
26370     } catch (...) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26373       };
26374     }
26375   }
26376
26377   jresult = (void *)result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26383   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26384
26385   arg1 = (Dali::Shader *)jarg1;
26386   {
26387     try {
26388       delete arg1;
26389     } catch (std::out_of_range& e) {
26390       {
26391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26392       };
26393     } catch (std::exception& e) {
26394       {
26395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26396       };
26397     } catch (Dali::DaliException e) {
26398       {
26399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26400       };
26401     } catch (...) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26404       };
26405     }
26406   }
26407
26408 }
26409
26410
26411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26412   void * jresult ;
26413   Dali::Shader *arg1 = 0 ;
26414   Dali::Shader *result = 0 ;
26415
26416   arg1 = (Dali::Shader *)jarg1;
26417   if (!arg1) {
26418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26419     return 0;
26420   }
26421   {
26422     try {
26423       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26424     } catch (std::out_of_range& e) {
26425       {
26426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26427       };
26428     } catch (std::exception& e) {
26429       {
26430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26431       };
26432     } catch (Dali::DaliException e) {
26433       {
26434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26435       };
26436     } catch (...) {
26437       {
26438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26439       };
26440     }
26441   }
26442
26443   jresult = (void *)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26449   void * jresult ;
26450   Dali::BaseHandle arg1 ;
26451   Dali::BaseHandle *argp1 ;
26452   Dali::Shader result;
26453
26454   argp1 = (Dali::BaseHandle *)jarg1;
26455   if (!argp1) {
26456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26457     return 0;
26458   }
26459   arg1 = *argp1;
26460   {
26461     try {
26462       result = Dali::Shader::DownCast(arg1);
26463     } catch (std::out_of_range& e) {
26464       {
26465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26466       };
26467     } catch (std::exception& e) {
26468       {
26469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (Dali::DaliException e) {
26472       {
26473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26474       };
26475     } catch (...) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26478       };
26479     }
26480   }
26481
26482   jresult = new Dali::Shader((const Dali::Shader &)result);
26483   return jresult;
26484 }
26485
26486
26487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26488   void * jresult ;
26489   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26490   Dali::Shader *arg2 = 0 ;
26491   Dali::Shader *result = 0 ;
26492
26493   arg1 = (Dali::Shader *)jarg1;
26494   arg2 = (Dali::Shader *)jarg2;
26495   if (!arg2) {
26496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26497     return 0;
26498   }
26499   {
26500     try {
26501       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26502     } catch (std::out_of_range& e) {
26503       {
26504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26505       };
26506     } catch (std::exception& e) {
26507       {
26508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26509       };
26510     } catch (Dali::DaliException e) {
26511       {
26512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26513       };
26514     } catch (...) {
26515       {
26516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26517       };
26518     }
26519   }
26520
26521   jresult = (void *)result;
26522   return jresult;
26523 }
26524
26525
26526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26527   int jresult ;
26528   int result;
26529
26530   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26531   jresult = (int)result;
26532   return jresult;
26533 }
26534
26535
26536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26537   int jresult ;
26538   int result;
26539
26540   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26541   jresult = (int)result;
26542   return jresult;
26543 }
26544
26545
26546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26547   int jresult ;
26548   int result;
26549
26550   result = (int)Dali::Renderer::Property::BLEND_MODE;
26551   jresult = (int)result;
26552   return jresult;
26553 }
26554
26555
26556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26557   int jresult ;
26558   int result;
26559
26560   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26561   jresult = (int)result;
26562   return jresult;
26563 }
26564
26565
26566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26567   int jresult ;
26568   int result;
26569
26570   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26571   jresult = (int)result;
26572   return jresult;
26573 }
26574
26575
26576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26577   int jresult ;
26578   int result;
26579
26580   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26581   jresult = (int)result;
26582   return jresult;
26583 }
26584
26585
26586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26587   int jresult ;
26588   int result;
26589
26590   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26591   jresult = (int)result;
26592   return jresult;
26593 }
26594
26595
26596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26597   int jresult ;
26598   int result;
26599
26600   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26601   jresult = (int)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26607   int jresult ;
26608   int result;
26609
26610   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26611   jresult = (int)result;
26612   return jresult;
26613 }
26614
26615
26616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26617   int jresult ;
26618   int result;
26619
26620   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26621   jresult = (int)result;
26622   return jresult;
26623 }
26624
26625
26626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26627   int jresult ;
26628   int result;
26629
26630   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26631   jresult = (int)result;
26632   return jresult;
26633 }
26634
26635
26636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26637   int jresult ;
26638   int result;
26639
26640   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26641   jresult = (int)result;
26642   return jresult;
26643 }
26644
26645
26646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26647   int jresult ;
26648   int result;
26649
26650   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26651   jresult = (int)result;
26652   return jresult;
26653 }
26654
26655
26656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26657   int jresult ;
26658   int result;
26659
26660   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26661   jresult = (int)result;
26662   return jresult;
26663 }
26664
26665
26666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26667   int jresult ;
26668   int result;
26669
26670   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26671   jresult = (int)result;
26672   return jresult;
26673 }
26674
26675
26676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26677   int jresult ;
26678   int result;
26679
26680   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26681   jresult = (int)result;
26682   return jresult;
26683 }
26684
26685
26686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26687   int jresult ;
26688   int result;
26689
26690   result = (int)Dali::Renderer::Property::RENDER_MODE;
26691   jresult = (int)result;
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26697   int jresult ;
26698   int result;
26699
26700   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26701   jresult = (int)result;
26702   return jresult;
26703 }
26704
26705
26706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26707   int jresult ;
26708   int result;
26709
26710   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26711   jresult = (int)result;
26712   return jresult;
26713 }
26714
26715
26716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26717   int jresult ;
26718   int result;
26719
26720   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26721   jresult = (int)result;
26722   return jresult;
26723 }
26724
26725
26726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26727   int jresult ;
26728   int result;
26729
26730   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26731   jresult = (int)result;
26732   return jresult;
26733 }
26734
26735
26736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26737   int jresult ;
26738   int result;
26739
26740   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26741   jresult = (int)result;
26742   return jresult;
26743 }
26744
26745
26746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26747   int jresult ;
26748   int result;
26749
26750   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26751   jresult = (int)result;
26752   return jresult;
26753 }
26754
26755
26756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26757   int jresult ;
26758   int result;
26759
26760   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26761   jresult = (int)result;
26762   return jresult;
26763 }
26764
26765
26766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26767   void * jresult ;
26768   Dali::Renderer::Property *result = 0 ;
26769
26770   {
26771     try {
26772       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26773     } catch (std::out_of_range& e) {
26774       {
26775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26776       };
26777     } catch (std::exception& e) {
26778       {
26779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (Dali::DaliException e) {
26782       {
26783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26784       };
26785     } catch (...) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26788       };
26789     }
26790   }
26791
26792   jresult = (void *)result;
26793   return jresult;
26794 }
26795
26796
26797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26798   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26799
26800   arg1 = (Dali::Renderer::Property *)jarg1;
26801   {
26802     try {
26803       delete arg1;
26804     } catch (std::out_of_range& e) {
26805       {
26806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26807       };
26808     } catch (std::exception& e) {
26809       {
26810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26811       };
26812     } catch (Dali::DaliException e) {
26813       {
26814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26815       };
26816     } catch (...) {
26817       {
26818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26819       };
26820     }
26821   }
26822
26823 }
26824
26825
26826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26827   void * jresult ;
26828   Dali::Geometry *arg1 = 0 ;
26829   Dali::Shader *arg2 = 0 ;
26830   Dali::Renderer result;
26831
26832   arg1 = (Dali::Geometry *)jarg1;
26833   if (!arg1) {
26834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26835     return 0;
26836   }
26837   arg2 = (Dali::Shader *)jarg2;
26838   if (!arg2) {
26839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26840     return 0;
26841   }
26842   {
26843     try {
26844       result = Dali::Renderer::New(*arg1,*arg2);
26845     } catch (std::out_of_range& e) {
26846       {
26847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26848       };
26849     } catch (std::exception& e) {
26850       {
26851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (Dali::DaliException e) {
26854       {
26855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26856       };
26857     } catch (...) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26860       };
26861     }
26862   }
26863
26864   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26865   return jresult;
26866 }
26867
26868
26869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26870   void * jresult ;
26871   Dali::Renderer *result = 0 ;
26872
26873   {
26874     try {
26875       result = (Dali::Renderer *)new Dali::Renderer();
26876     } catch (std::out_of_range& e) {
26877       {
26878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26879       };
26880     } catch (std::exception& e) {
26881       {
26882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26883       };
26884     } catch (Dali::DaliException e) {
26885       {
26886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26887       };
26888     } catch (...) {
26889       {
26890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26891       };
26892     }
26893   }
26894
26895   jresult = (void *)result;
26896   return jresult;
26897 }
26898
26899
26900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26901   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26902
26903   arg1 = (Dali::Renderer *)jarg1;
26904   {
26905     try {
26906       delete arg1;
26907     } catch (std::out_of_range& e) {
26908       {
26909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26910       };
26911     } catch (std::exception& e) {
26912       {
26913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26914       };
26915     } catch (Dali::DaliException e) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26918       };
26919     } catch (...) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26922       };
26923     }
26924   }
26925
26926 }
26927
26928
26929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26930   void * jresult ;
26931   Dali::Renderer *arg1 = 0 ;
26932   Dali::Renderer *result = 0 ;
26933
26934   arg1 = (Dali::Renderer *)jarg1;
26935   if (!arg1) {
26936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26937     return 0;
26938   }
26939   {
26940     try {
26941       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26942     } catch (std::out_of_range& e) {
26943       {
26944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26945       };
26946     } catch (std::exception& e) {
26947       {
26948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26949       };
26950     } catch (Dali::DaliException e) {
26951       {
26952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26953       };
26954     } catch (...) {
26955       {
26956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26957       };
26958     }
26959   }
26960
26961   jresult = (void *)result;
26962   return jresult;
26963 }
26964
26965
26966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26967   void * jresult ;
26968   Dali::BaseHandle arg1 ;
26969   Dali::BaseHandle *argp1 ;
26970   Dali::Renderer result;
26971
26972   argp1 = (Dali::BaseHandle *)jarg1;
26973   if (!argp1) {
26974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26975     return 0;
26976   }
26977   arg1 = *argp1;
26978   {
26979     try {
26980       result = Dali::Renderer::DownCast(arg1);
26981     } catch (std::out_of_range& e) {
26982       {
26983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26984       };
26985     } catch (std::exception& e) {
26986       {
26987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26988       };
26989     } catch (Dali::DaliException e) {
26990       {
26991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26992       };
26993     } catch (...) {
26994       {
26995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26996       };
26997     }
26998   }
26999
27000   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27001   return jresult;
27002 }
27003
27004
27005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27006   void * jresult ;
27007   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27008   Dali::Renderer *arg2 = 0 ;
27009   Dali::Renderer *result = 0 ;
27010
27011   arg1 = (Dali::Renderer *)jarg1;
27012   arg2 = (Dali::Renderer *)jarg2;
27013   if (!arg2) {
27014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27015     return 0;
27016   }
27017   {
27018     try {
27019       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27020     } catch (std::out_of_range& e) {
27021       {
27022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27023       };
27024     } catch (std::exception& e) {
27025       {
27026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (Dali::DaliException e) {
27029       {
27030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27031       };
27032     } catch (...) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27035       };
27036     }
27037   }
27038
27039   jresult = (void *)result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27045   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27046   Dali::Geometry *arg2 = 0 ;
27047
27048   arg1 = (Dali::Renderer *)jarg1;
27049   arg2 = (Dali::Geometry *)jarg2;
27050   if (!arg2) {
27051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27052     return ;
27053   }
27054   {
27055     try {
27056       (arg1)->SetGeometry(*arg2);
27057     } catch (std::out_of_range& e) {
27058       {
27059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27060       };
27061     } catch (std::exception& e) {
27062       {
27063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (Dali::DaliException e) {
27066       {
27067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27068       };
27069     } catch (...) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27072       };
27073     }
27074   }
27075
27076 }
27077
27078
27079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27080   void * jresult ;
27081   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27082   Dali::Geometry result;
27083
27084   arg1 = (Dali::Renderer *)jarg1;
27085   {
27086     try {
27087       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27088     } catch (std::out_of_range& e) {
27089       {
27090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (std::exception& e) {
27093       {
27094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (Dali::DaliException e) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27099       };
27100     } catch (...) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27103       };
27104     }
27105   }
27106
27107   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27108   return jresult;
27109 }
27110
27111
27112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27113   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27114   int arg2 ;
27115   int arg3 ;
27116
27117   arg1 = (Dali::Renderer *)jarg1;
27118   arg2 = (int)jarg2;
27119   arg3 = (int)jarg3;
27120   {
27121     try {
27122       (arg1)->SetIndexRange(arg2,arg3);
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (Dali::DaliException e) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27138       };
27139     }
27140   }
27141
27142 }
27143
27144
27145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27146   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27147   Dali::TextureSet *arg2 = 0 ;
27148
27149   arg1 = (Dali::Renderer *)jarg1;
27150   arg2 = (Dali::TextureSet *)jarg2;
27151   if (!arg2) {
27152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27153     return ;
27154   }
27155   {
27156     try {
27157       (arg1)->SetTextures(*arg2);
27158     } catch (std::out_of_range& e) {
27159       {
27160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27161       };
27162     } catch (std::exception& e) {
27163       {
27164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27165       };
27166     } catch (Dali::DaliException e) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27169       };
27170     } catch (...) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27173       };
27174     }
27175   }
27176
27177 }
27178
27179
27180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27181   void * jresult ;
27182   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27183   Dali::TextureSet result;
27184
27185   arg1 = (Dali::Renderer *)jarg1;
27186   {
27187     try {
27188       result = ((Dali::Renderer const *)arg1)->GetTextures();
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207
27208   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27209   return jresult;
27210 }
27211
27212
27213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27214   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27215   Dali::Shader *arg2 = 0 ;
27216
27217   arg1 = (Dali::Renderer *)jarg1;
27218   arg2 = (Dali::Shader *)jarg2;
27219   if (!arg2) {
27220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27221     return ;
27222   }
27223   {
27224     try {
27225       (arg1)->SetShader(*arg2);
27226     } catch (std::out_of_range& e) {
27227       {
27228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27229       };
27230     } catch (std::exception& e) {
27231       {
27232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27233       };
27234     } catch (Dali::DaliException e) {
27235       {
27236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27237       };
27238     } catch (...) {
27239       {
27240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27241       };
27242     }
27243   }
27244
27245 }
27246
27247
27248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27249   void * jresult ;
27250   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27251   Dali::Shader result;
27252
27253   arg1 = (Dali::Renderer *)jarg1;
27254   {
27255     try {
27256       result = ((Dali::Renderer const *)arg1)->GetShader();
27257     } catch (std::out_of_range& e) {
27258       {
27259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (std::exception& e) {
27262       {
27263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (Dali::DaliException e) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27268       };
27269     } catch (...) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27272       };
27273     }
27274   }
27275
27276   jresult = new Dali::Shader((const Dali::Shader &)result);
27277   return jresult;
27278 }
27279
27280
27281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27282   void * jresult ;
27283   Dali::FrameBuffer::Attachment *result = 0 ;
27284
27285   {
27286     try {
27287       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27288     } catch (std::out_of_range& e) {
27289       {
27290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27291       };
27292     } catch (std::exception& e) {
27293       {
27294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (Dali::DaliException e) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27299       };
27300     } catch (...) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27303       };
27304     }
27305   }
27306
27307   jresult = (void *)result;
27308   return jresult;
27309 }
27310
27311
27312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27313   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27314
27315   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27316   {
27317     try {
27318       delete arg1;
27319     } catch (std::out_of_range& e) {
27320       {
27321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27322       };
27323     } catch (std::exception& e) {
27324       {
27325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27326       };
27327     } catch (Dali::DaliException e) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27330       };
27331     } catch (...) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27334       };
27335     }
27336   }
27337
27338 }
27339
27340
27341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27342   void * jresult ;
27343   unsigned int arg1 ;
27344   unsigned int arg2 ;
27345   unsigned int arg3 ;
27346   Dali::FrameBuffer result;
27347
27348   arg1 = (unsigned int)jarg1;
27349   arg2 = (unsigned int)jarg2;
27350   arg3 = (unsigned int)jarg3;
27351   {
27352     try {
27353       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27354     } catch (std::out_of_range& e) {
27355       {
27356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27357       };
27358     } catch (std::exception& e) {
27359       {
27360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (Dali::DaliException e) {
27363       {
27364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27369       };
27370     }
27371   }
27372
27373   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27374   return jresult;
27375 }
27376
27377
27378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27379   void * jresult ;
27380   Dali::FrameBuffer *result = 0 ;
27381
27382   {
27383     try {
27384       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27385     } catch (std::out_of_range& e) {
27386       {
27387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27388       };
27389     } catch (std::exception& e) {
27390       {
27391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (Dali::DaliException e) {
27394       {
27395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27396       };
27397     } catch (...) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27400       };
27401     }
27402   }
27403
27404   jresult = (void *)result;
27405   return jresult;
27406 }
27407
27408
27409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27410   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27411
27412   arg1 = (Dali::FrameBuffer *)jarg1;
27413   {
27414     try {
27415       delete arg1;
27416     } catch (std::out_of_range& e) {
27417       {
27418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27419       };
27420     } catch (std::exception& e) {
27421       {
27422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27423       };
27424     } catch (Dali::DaliException e) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27427       };
27428     } catch (...) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27431       };
27432     }
27433   }
27434
27435 }
27436
27437
27438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27439   void * jresult ;
27440   Dali::FrameBuffer *arg1 = 0 ;
27441   Dali::FrameBuffer *result = 0 ;
27442
27443   arg1 = (Dali::FrameBuffer *)jarg1;
27444   if (!arg1) {
27445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27446     return 0;
27447   }
27448   {
27449     try {
27450       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27451     } catch (std::out_of_range& e) {
27452       {
27453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27454       };
27455     } catch (std::exception& e) {
27456       {
27457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27458       };
27459     } catch (Dali::DaliException e) {
27460       {
27461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27462       };
27463     } catch (...) {
27464       {
27465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27466       };
27467     }
27468   }
27469
27470   jresult = (void *)result;
27471   return jresult;
27472 }
27473
27474
27475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27476   void * jresult ;
27477   Dali::BaseHandle arg1 ;
27478   Dali::BaseHandle *argp1 ;
27479   Dali::FrameBuffer result;
27480
27481   argp1 = (Dali::BaseHandle *)jarg1;
27482   if (!argp1) {
27483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27484     return 0;
27485   }
27486   arg1 = *argp1;
27487   {
27488     try {
27489       result = Dali::FrameBuffer::DownCast(arg1);
27490     } catch (std::out_of_range& e) {
27491       {
27492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27493       };
27494     } catch (std::exception& e) {
27495       {
27496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27497       };
27498     } catch (Dali::DaliException e) {
27499       {
27500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27501       };
27502     } catch (...) {
27503       {
27504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27505       };
27506     }
27507   }
27508
27509   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27510   return jresult;
27511 }
27512
27513
27514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27515   void * jresult ;
27516   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27517   Dali::FrameBuffer *arg2 = 0 ;
27518   Dali::FrameBuffer *result = 0 ;
27519
27520   arg1 = (Dali::FrameBuffer *)jarg1;
27521   arg2 = (Dali::FrameBuffer *)jarg2;
27522   if (!arg2) {
27523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27524     return 0;
27525   }
27526   {
27527     try {
27528       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27529     } catch (std::out_of_range& e) {
27530       {
27531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27532       };
27533     } catch (std::exception& e) {
27534       {
27535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (Dali::DaliException e) {
27538       {
27539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27540       };
27541     } catch (...) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27544       };
27545     }
27546   }
27547
27548   jresult = (void *)result;
27549   return jresult;
27550 }
27551
27552
27553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27554   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27555   Dali::Texture *arg2 = 0 ;
27556
27557   arg1 = (Dali::FrameBuffer *)jarg1;
27558   arg2 = (Dali::Texture *)jarg2;
27559   if (!arg2) {
27560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27561     return ;
27562   }
27563   {
27564     try {
27565       (arg1)->AttachColorTexture(*arg2);
27566     } catch (std::out_of_range& e) {
27567       {
27568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27569       };
27570     } catch (std::exception& e) {
27571       {
27572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27573       };
27574     } catch (Dali::DaliException e) {
27575       {
27576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27577       };
27578     } catch (...) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27581       };
27582     }
27583   }
27584
27585 }
27586
27587
27588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27589   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27590   Dali::Texture *arg2 = 0 ;
27591   unsigned int arg3 ;
27592   unsigned int arg4 ;
27593
27594   arg1 = (Dali::FrameBuffer *)jarg1;
27595   arg2 = (Dali::Texture *)jarg2;
27596   if (!arg2) {
27597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27598     return ;
27599   }
27600   arg3 = (unsigned int)jarg3;
27601   arg4 = (unsigned int)jarg4;
27602   {
27603     try {
27604       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27605     } catch (std::out_of_range& e) {
27606       {
27607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27608       };
27609     } catch (std::exception& e) {
27610       {
27611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27612       };
27613     } catch (Dali::DaliException e) {
27614       {
27615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27616       };
27617     } catch (...) {
27618       {
27619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27620       };
27621     }
27622   }
27623
27624 }
27625
27626
27627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27628   void * jresult ;
27629   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27630   Dali::Texture result;
27631
27632   arg1 = (Dali::FrameBuffer *)jarg1;
27633   {
27634     try {
27635       result = (arg1)->GetColorTexture();
27636     } catch (std::out_of_range& e) {
27637       {
27638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27639       };
27640     } catch (std::exception& e) {
27641       {
27642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (Dali::DaliException e) {
27645       {
27646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27647       };
27648     } catch (...) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27651       };
27652     }
27653   }
27654
27655   jresult = new Dali::Texture((const Dali::Texture &)result);
27656   return jresult;
27657 }
27658
27659
27660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27661   void * jresult ;
27662   Dali::RenderTaskList *result = 0 ;
27663
27664   {
27665     try {
27666       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27667     } catch (std::out_of_range& e) {
27668       {
27669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27670       };
27671     } catch (std::exception& e) {
27672       {
27673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (Dali::DaliException e) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27678       };
27679     } catch (...) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27682       };
27683     }
27684   }
27685
27686   jresult = (void *)result;
27687   return jresult;
27688 }
27689
27690
27691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27692   void * jresult ;
27693   Dali::BaseHandle arg1 ;
27694   Dali::BaseHandle *argp1 ;
27695   Dali::RenderTaskList result;
27696
27697   argp1 = (Dali::BaseHandle *)jarg1;
27698   if (!argp1) {
27699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27700     return 0;
27701   }
27702   arg1 = *argp1;
27703   {
27704     try {
27705       result = Dali::RenderTaskList::DownCast(arg1);
27706     } catch (std::out_of_range& e) {
27707       {
27708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27709       };
27710     } catch (std::exception& e) {
27711       {
27712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27713       };
27714     } catch (Dali::DaliException e) {
27715       {
27716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27717       };
27718     } catch (...) {
27719       {
27720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27721       };
27722     }
27723   }
27724
27725   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27726   return jresult;
27727 }
27728
27729
27730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27731   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27732
27733   arg1 = (Dali::RenderTaskList *)jarg1;
27734   {
27735     try {
27736       delete arg1;
27737     } catch (std::out_of_range& e) {
27738       {
27739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27740       };
27741     } catch (std::exception& e) {
27742       {
27743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27744       };
27745     } catch (Dali::DaliException e) {
27746       {
27747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27748       };
27749     } catch (...) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27752       };
27753     }
27754   }
27755
27756 }
27757
27758
27759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27760   void * jresult ;
27761   Dali::RenderTaskList *arg1 = 0 ;
27762   Dali::RenderTaskList *result = 0 ;
27763
27764   arg1 = (Dali::RenderTaskList *)jarg1;
27765   if (!arg1) {
27766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27767     return 0;
27768   }
27769   {
27770     try {
27771       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27772     } catch (std::out_of_range& e) {
27773       {
27774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27775       };
27776     } catch (std::exception& e) {
27777       {
27778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (Dali::DaliException e) {
27781       {
27782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27783       };
27784     } catch (...) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27787       };
27788     }
27789   }
27790
27791   jresult = (void *)result;
27792   return jresult;
27793 }
27794
27795
27796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27797   void * jresult ;
27798   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27799   Dali::RenderTaskList *arg2 = 0 ;
27800   Dali::RenderTaskList *result = 0 ;
27801
27802   arg1 = (Dali::RenderTaskList *)jarg1;
27803   arg2 = (Dali::RenderTaskList *)jarg2;
27804   if (!arg2) {
27805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27806     return 0;
27807   }
27808   {
27809     try {
27810       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27811     } catch (std::out_of_range& e) {
27812       {
27813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27814       };
27815     } catch (std::exception& e) {
27816       {
27817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27818       };
27819     } catch (Dali::DaliException e) {
27820       {
27821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27822       };
27823     } catch (...) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27826       };
27827     }
27828   }
27829
27830   jresult = (void *)result;
27831   return jresult;
27832 }
27833
27834
27835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27836   void * jresult ;
27837   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27838   Dali::RenderTask result;
27839
27840   arg1 = (Dali::RenderTaskList *)jarg1;
27841   {
27842     try {
27843       result = (arg1)->CreateTask();
27844     } catch (std::out_of_range& e) {
27845       {
27846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27847       };
27848     } catch (std::exception& e) {
27849       {
27850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27851       };
27852     } catch (Dali::DaliException e) {
27853       {
27854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27855       };
27856     } catch (...) {
27857       {
27858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27859       };
27860     }
27861   }
27862
27863   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27864   return jresult;
27865 }
27866
27867
27868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27869   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27870   Dali::RenderTask arg2 ;
27871   Dali::RenderTask *argp2 ;
27872
27873   arg1 = (Dali::RenderTaskList *)jarg1;
27874   argp2 = (Dali::RenderTask *)jarg2;
27875   if (!argp2) {
27876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27877     return ;
27878   }
27879   arg2 = *argp2;
27880   {
27881     try {
27882       (arg1)->RemoveTask(arg2);
27883     } catch (std::out_of_range& e) {
27884       {
27885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27886       };
27887     } catch (std::exception& e) {
27888       {
27889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27890       };
27891     } catch (Dali::DaliException e) {
27892       {
27893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27894       };
27895     } catch (...) {
27896       {
27897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27898       };
27899     }
27900   }
27901
27902 }
27903
27904
27905 //// ===============================================end part 1 =================
27906
27907 //// ========================= part 2 ===============================
27908
27909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27910   unsigned int jresult ;
27911   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27912   unsigned int result;
27913
27914   arg1 = (Dali::RenderTaskList *)jarg1;
27915   {
27916     try {
27917       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27918     } catch (std::out_of_range& e) {
27919       {
27920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27921       };
27922     } catch (std::exception& e) {
27923       {
27924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27925       };
27926     } catch (Dali::DaliException e) {
27927       {
27928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27929       };
27930     } catch (...) {
27931       {
27932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27933       };
27934     }
27935   }
27936
27937   jresult = result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27943   void * jresult ;
27944   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27945   unsigned int arg2 ;
27946   Dali::RenderTask result;
27947
27948   arg1 = (Dali::RenderTaskList *)jarg1;
27949   arg2 = (unsigned int)jarg2;
27950   {
27951     try {
27952       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27953     } catch (std::out_of_range& e) {
27954       {
27955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27956       };
27957     } catch (std::exception& e) {
27958       {
27959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (Dali::DaliException e) {
27962       {
27963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971
27972   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27973   return jresult;
27974 }
27975
27976
27977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27978   int jresult ;
27979   int result;
27980
27981   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27982   jresult = (int)result;
27983   return jresult;
27984 }
27985
27986
27987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27988   int jresult ;
27989   int result;
27990
27991   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27992   jresult = (int)result;
27993   return jresult;
27994 }
27995
27996
27997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27998   int jresult ;
27999   int result;
28000
28001   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28002   jresult = (int)result;
28003   return jresult;
28004 }
28005
28006
28007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28008   int jresult ;
28009   int result;
28010
28011   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28012   jresult = (int)result;
28013   return jresult;
28014 }
28015
28016
28017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28018   void * jresult ;
28019   Dali::RenderTask::Property *result = 0 ;
28020
28021   {
28022     try {
28023       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28024     } catch (std::out_of_range& e) {
28025       {
28026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28027       };
28028     } catch (std::exception& e) {
28029       {
28030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28031       };
28032     } catch (Dali::DaliException e) {
28033       {
28034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28035       };
28036     } catch (...) {
28037       {
28038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28039       };
28040     }
28041   }
28042
28043   jresult = (void *)result;
28044   return jresult;
28045 }
28046
28047
28048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28049   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28050
28051   arg1 = (Dali::RenderTask::Property *)jarg1;
28052   {
28053     try {
28054       delete arg1;
28055     } catch (std::out_of_range& e) {
28056       {
28057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28058       };
28059     } catch (std::exception& e) {
28060       {
28061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28062       };
28063     } catch (Dali::DaliException e) {
28064       {
28065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28066       };
28067     } catch (...) {
28068       {
28069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28070       };
28071     }
28072   }
28073
28074 }
28075
28076
28077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28078   void * jresult ;
28079   bool (*result)(Dali::Vector2 &) = 0 ;
28080
28081   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28082   jresult = (void *)result;
28083   return jresult;
28084 }
28085
28086
28087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28088   void * jresult ;
28089   bool (*result)(Dali::Vector2 &) = 0 ;
28090
28091   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28092   jresult = (void *)result;
28093   return jresult;
28094 }
28095
28096
28097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28098   unsigned int jresult ;
28099   bool result;
28100
28101   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28102   jresult = result;
28103   return jresult;
28104 }
28105
28106
28107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28108   unsigned int jresult ;
28109   bool result;
28110
28111   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28112   jresult = result;
28113   return jresult;
28114 }
28115
28116
28117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28118   void * jresult ;
28119   Dali::Vector4 *result = 0 ;
28120
28121   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28122   jresult = (void *)result;
28123   return jresult;
28124 }
28125
28126
28127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28128   unsigned int jresult ;
28129   bool result;
28130
28131   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28132   jresult = result;
28133   return jresult;
28134 }
28135
28136
28137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28138   unsigned int jresult ;
28139   bool result;
28140
28141   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28142   jresult = result;
28143   return jresult;
28144 }
28145
28146
28147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28148   unsigned int jresult ;
28149   unsigned int result;
28150
28151   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28152   jresult = result;
28153   return jresult;
28154 }
28155
28156
28157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28158   void * jresult ;
28159   Dali::RenderTask *result = 0 ;
28160
28161   {
28162     try {
28163       result = (Dali::RenderTask *)new Dali::RenderTask();
28164     } catch (std::out_of_range& e) {
28165       {
28166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28167       };
28168     } catch (std::exception& e) {
28169       {
28170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28171       };
28172     } catch (Dali::DaliException e) {
28173       {
28174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28175       };
28176     } catch (...) {
28177       {
28178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28179       };
28180     }
28181   }
28182
28183   jresult = (void *)result;
28184   return jresult;
28185 }
28186
28187
28188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28189   void * jresult ;
28190   Dali::BaseHandle arg1 ;
28191   Dali::BaseHandle *argp1 ;
28192   Dali::RenderTask result;
28193
28194   argp1 = (Dali::BaseHandle *)jarg1;
28195   if (!argp1) {
28196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28197     return 0;
28198   }
28199   arg1 = *argp1;
28200   {
28201     try {
28202       result = Dali::RenderTask::DownCast(arg1);
28203     } catch (std::out_of_range& e) {
28204       {
28205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28206       };
28207     } catch (std::exception& e) {
28208       {
28209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (Dali::DaliException e) {
28212       {
28213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28214       };
28215     } catch (...) {
28216       {
28217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28218       };
28219     }
28220   }
28221
28222   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28223   return jresult;
28224 }
28225
28226
28227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28228   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28229
28230   arg1 = (Dali::RenderTask *)jarg1;
28231   {
28232     try {
28233       delete arg1;
28234     } catch (std::out_of_range& e) {
28235       {
28236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28237       };
28238     } catch (std::exception& e) {
28239       {
28240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28241       };
28242     } catch (Dali::DaliException e) {
28243       {
28244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28245       };
28246     } catch (...) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28249       };
28250     }
28251   }
28252
28253 }
28254
28255
28256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28257   void * jresult ;
28258   Dali::RenderTask *arg1 = 0 ;
28259   Dali::RenderTask *result = 0 ;
28260
28261   arg1 = (Dali::RenderTask *)jarg1;
28262   if (!arg1) {
28263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28264     return 0;
28265   }
28266   {
28267     try {
28268       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28269     } catch (std::out_of_range& e) {
28270       {
28271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28272       };
28273     } catch (std::exception& e) {
28274       {
28275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (Dali::DaliException e) {
28278       {
28279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28280       };
28281     } catch (...) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28284       };
28285     }
28286   }
28287
28288   jresult = (void *)result;
28289   return jresult;
28290 }
28291
28292
28293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28294   void * jresult ;
28295   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28296   Dali::RenderTask *arg2 = 0 ;
28297   Dali::RenderTask *result = 0 ;
28298
28299   arg1 = (Dali::RenderTask *)jarg1;
28300   arg2 = (Dali::RenderTask *)jarg2;
28301   if (!arg2) {
28302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28303     return 0;
28304   }
28305   {
28306     try {
28307       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28308     } catch (std::out_of_range& e) {
28309       {
28310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28311       };
28312     } catch (std::exception& e) {
28313       {
28314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (Dali::DaliException e) {
28317       {
28318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28319       };
28320     } catch (...) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28323       };
28324     }
28325   }
28326
28327   jresult = (void *)result;
28328   return jresult;
28329 }
28330
28331
28332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28333   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28334   Dali::Actor arg2 ;
28335   Dali::Actor *argp2 ;
28336
28337   arg1 = (Dali::RenderTask *)jarg1;
28338   argp2 = (Dali::Actor *)jarg2;
28339   if (!argp2) {
28340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28341     return ;
28342   }
28343   arg2 = *argp2;
28344   {
28345     try {
28346       (arg1)->SetSourceActor(arg2);
28347     } catch (std::out_of_range& e) {
28348       {
28349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28350       };
28351     } catch (std::exception& e) {
28352       {
28353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (Dali::DaliException e) {
28356       {
28357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28358       };
28359     } catch (...) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28362       };
28363     }
28364   }
28365
28366 }
28367
28368
28369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28370   void * jresult ;
28371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28372   Dali::Actor result;
28373
28374   arg1 = (Dali::RenderTask *)jarg1;
28375   {
28376     try {
28377       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28378     } catch (std::out_of_range& e) {
28379       {
28380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28381       };
28382     } catch (std::exception& e) {
28383       {
28384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (Dali::DaliException e) {
28387       {
28388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28389       };
28390     } catch (...) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28393       };
28394     }
28395   }
28396
28397   jresult = new Dali::Actor((const Dali::Actor &)result);
28398   return jresult;
28399 }
28400
28401
28402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28403   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28404   bool arg2 ;
28405
28406   arg1 = (Dali::RenderTask *)jarg1;
28407   arg2 = jarg2 ? true : false;
28408   {
28409     try {
28410       (arg1)->SetExclusive(arg2);
28411     } catch (std::out_of_range& e) {
28412       {
28413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28414       };
28415     } catch (std::exception& e) {
28416       {
28417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (Dali::DaliException e) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28422       };
28423     } catch (...) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28426       };
28427     }
28428   }
28429
28430 }
28431
28432
28433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28434   unsigned int jresult ;
28435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28436   bool result;
28437
28438   arg1 = (Dali::RenderTask *)jarg1;
28439   {
28440     try {
28441       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28442     } catch (std::out_of_range& e) {
28443       {
28444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (std::exception& e) {
28447       {
28448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (Dali::DaliException e) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28453       };
28454     } catch (...) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28457       };
28458     }
28459   }
28460
28461   jresult = result;
28462   return jresult;
28463 }
28464
28465
28466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28467   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28468   bool arg2 ;
28469
28470   arg1 = (Dali::RenderTask *)jarg1;
28471   arg2 = jarg2 ? true : false;
28472   {
28473     try {
28474       (arg1)->SetInputEnabled(arg2);
28475     } catch (std::out_of_range& e) {
28476       {
28477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (std::exception& e) {
28480       {
28481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (Dali::DaliException e) {
28484       {
28485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28486       };
28487     } catch (...) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28490       };
28491     }
28492   }
28493
28494 }
28495
28496
28497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28498   unsigned int jresult ;
28499   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28500   bool result;
28501
28502   arg1 = (Dali::RenderTask *)jarg1;
28503   {
28504     try {
28505       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28521       };
28522     }
28523   }
28524
28525   jresult = result;
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28532   Dali::CameraActor arg2 ;
28533   Dali::CameraActor *argp2 ;
28534
28535   arg1 = (Dali::RenderTask *)jarg1;
28536   argp2 = (Dali::CameraActor *)jarg2;
28537   if (!argp2) {
28538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28539     return ;
28540   }
28541   arg2 = *argp2;
28542   {
28543     try {
28544       (arg1)->SetCameraActor(arg2);
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (Dali::DaliException e) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28556       };
28557     } catch (...) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28560       };
28561     }
28562   }
28563
28564 }
28565
28566
28567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28568   void * jresult ;
28569   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28570   Dali::CameraActor result;
28571
28572   arg1 = (Dali::RenderTask *)jarg1;
28573   {
28574     try {
28575       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28576     } catch (std::out_of_range& e) {
28577       {
28578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28579       };
28580     } catch (std::exception& e) {
28581       {
28582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (Dali::DaliException e) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28587       };
28588     } catch (...) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28591       };
28592     }
28593   }
28594
28595   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28596   return jresult;
28597 }
28598
28599
28600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28601   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28602   Dali::FrameBufferImage arg2 ;
28603   Dali::FrameBufferImage *argp2 ;
28604
28605   arg1 = (Dali::RenderTask *)jarg1;
28606   argp2 = (Dali::FrameBufferImage *)jarg2;
28607   if (!argp2) {
28608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28609     return ;
28610   }
28611   arg2 = *argp2;
28612   {
28613     try {
28614       (arg1)->SetTargetFrameBuffer(arg2);
28615     } catch (std::out_of_range& e) {
28616       {
28617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28618       };
28619     } catch (std::exception& e) {
28620       {
28621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (Dali::DaliException e) {
28624       {
28625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28626       };
28627     } catch (...) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28630       };
28631     }
28632   }
28633
28634 }
28635
28636
28637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28638   void * jresult ;
28639   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28640   Dali::FrameBufferImage result;
28641
28642   arg1 = (Dali::RenderTask *)jarg1;
28643   {
28644     try {
28645       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28646     } catch (std::out_of_range& e) {
28647       {
28648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28649       };
28650     } catch (std::exception& e) {
28651       {
28652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (Dali::DaliException e) {
28655       {
28656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28657       };
28658     } catch (...) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28661       };
28662     }
28663   }
28664
28665   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28666   return jresult;
28667 }
28668
28669
28670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28672   Dali::FrameBuffer arg2 ;
28673   Dali::FrameBuffer *argp2 ;
28674
28675   arg1 = (Dali::RenderTask *)jarg1;
28676   argp2 = (Dali::FrameBuffer *)jarg2;
28677   if (!argp2) {
28678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28679     return ;
28680   }
28681   arg2 = *argp2;
28682   {
28683     try {
28684       (arg1)->SetFrameBuffer(arg2);
28685     } catch (std::out_of_range& e) {
28686       {
28687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28688       };
28689     } catch (std::exception& e) {
28690       {
28691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28692       };
28693     } catch (Dali::DaliException e) {
28694       {
28695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28696       };
28697     } catch (...) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28700       };
28701     }
28702   }
28703
28704 }
28705
28706
28707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28708   void * jresult ;
28709   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28710   Dali::FrameBuffer result;
28711
28712   arg1 = (Dali::RenderTask *)jarg1;
28713   {
28714     try {
28715       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28716     } catch (std::out_of_range& e) {
28717       {
28718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28719       };
28720     } catch (std::exception& e) {
28721       {
28722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28723       };
28724     } catch (Dali::DaliException e) {
28725       {
28726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28727       };
28728     } catch (...) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28731       };
28732     }
28733   }
28734
28735   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28736   return jresult;
28737 }
28738
28739
28740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28741   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28742   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28743
28744   arg1 = (Dali::RenderTask *)jarg1;
28745   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28746   {
28747     try {
28748       (arg1)->SetScreenToFrameBufferFunction(arg2);
28749     } catch (std::out_of_range& e) {
28750       {
28751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (std::exception& e) {
28754       {
28755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (Dali::DaliException e) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28760       };
28761     } catch (...) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28764       };
28765     }
28766   }
28767
28768 }
28769
28770
28771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28772   void * jresult ;
28773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28774   Dali::RenderTask::ScreenToFrameBufferFunction result;
28775
28776   arg1 = (Dali::RenderTask *)jarg1;
28777   {
28778     try {
28779       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28780     } catch (std::out_of_range& e) {
28781       {
28782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (std::exception& e) {
28785       {
28786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (Dali::DaliException e) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28791       };
28792     } catch (...) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28795       };
28796     }
28797   }
28798
28799   jresult = (void *)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28805   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28806   Dali::Actor arg2 ;
28807   Dali::Actor *argp2 ;
28808
28809   arg1 = (Dali::RenderTask *)jarg1;
28810   argp2 = (Dali::Actor *)jarg2;
28811   if (!argp2) {
28812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28813     return ;
28814   }
28815   arg2 = *argp2;
28816   {
28817     try {
28818       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28819     } catch (std::out_of_range& e) {
28820       {
28821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28822       };
28823     } catch (std::exception& e) {
28824       {
28825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28826       };
28827     } catch (Dali::DaliException e) {
28828       {
28829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28830       };
28831     } catch (...) {
28832       {
28833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28834       };
28835     }
28836   }
28837
28838 }
28839
28840
28841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28842   void * jresult ;
28843   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28844   Dali::Actor result;
28845
28846   arg1 = (Dali::RenderTask *)jarg1;
28847   {
28848     try {
28849       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28850     } catch (std::out_of_range& e) {
28851       {
28852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28853       };
28854     } catch (std::exception& e) {
28855       {
28856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28857       };
28858     } catch (Dali::DaliException e) {
28859       {
28860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28861       };
28862     } catch (...) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28865       };
28866     }
28867   }
28868
28869   jresult = new Dali::Actor((const Dali::Actor &)result);
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28875   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28876   Dali::Vector2 arg2 ;
28877   Dali::Vector2 *argp2 ;
28878
28879   arg1 = (Dali::RenderTask *)jarg1;
28880   argp2 = (Dali::Vector2 *)jarg2;
28881   if (!argp2) {
28882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28883     return ;
28884   }
28885   arg2 = *argp2;
28886   {
28887     try {
28888       (arg1)->SetViewportPosition(arg2);
28889     } catch (std::out_of_range& e) {
28890       {
28891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28892       };
28893     } catch (std::exception& e) {
28894       {
28895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (Dali::DaliException e) {
28898       {
28899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28900       };
28901     } catch (...) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28904       };
28905     }
28906   }
28907
28908 }
28909
28910
28911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28912   void * jresult ;
28913   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28914   Dali::Vector2 result;
28915
28916   arg1 = (Dali::RenderTask *)jarg1;
28917   {
28918     try {
28919       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28920     } catch (std::out_of_range& e) {
28921       {
28922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28923       };
28924     } catch (std::exception& e) {
28925       {
28926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (Dali::DaliException e) {
28929       {
28930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28931       };
28932     } catch (...) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28935       };
28936     }
28937   }
28938
28939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28945   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28946   Dali::Vector2 arg2 ;
28947   Dali::Vector2 *argp2 ;
28948
28949   arg1 = (Dali::RenderTask *)jarg1;
28950   argp2 = (Dali::Vector2 *)jarg2;
28951   if (!argp2) {
28952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28953     return ;
28954   }
28955   arg2 = *argp2;
28956   {
28957     try {
28958       (arg1)->SetViewportSize(arg2);
28959     } catch (std::out_of_range& e) {
28960       {
28961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28962       };
28963     } catch (std::exception& e) {
28964       {
28965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (Dali::DaliException e) {
28968       {
28969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28974       };
28975     }
28976   }
28977
28978 }
28979
28980
28981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28982   void * jresult ;
28983   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28984   Dali::Vector2 result;
28985
28986   arg1 = (Dali::RenderTask *)jarg1;
28987   {
28988     try {
28989       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28990     } catch (std::out_of_range& e) {
28991       {
28992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28993       };
28994     } catch (std::exception& e) {
28995       {
28996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (Dali::DaliException e) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29001       };
29002     } catch (...) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29005       };
29006     }
29007   }
29008
29009   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29016   Dali::Viewport arg2 ;
29017   Dali::Viewport *argp2 ;
29018
29019   arg1 = (Dali::RenderTask *)jarg1;
29020   argp2 = (Dali::Viewport *)jarg2;
29021   if (!argp2) {
29022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29023     return ;
29024   }
29025   arg2 = *argp2;
29026   {
29027     try {
29028       (arg1)->SetViewport(arg2);
29029     } catch (std::out_of_range& e) {
29030       {
29031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29032       };
29033     } catch (std::exception& e) {
29034       {
29035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (Dali::DaliException e) {
29038       {
29039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29040       };
29041     } catch (...) {
29042       {
29043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29044       };
29045     }
29046   }
29047
29048 }
29049
29050
29051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29052   void * jresult ;
29053   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29054   Dali::Viewport result;
29055
29056   arg1 = (Dali::RenderTask *)jarg1;
29057   {
29058     try {
29059       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29060     } catch (std::out_of_range& e) {
29061       {
29062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29063       };
29064     } catch (std::exception& e) {
29065       {
29066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (Dali::DaliException e) {
29069       {
29070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29071       };
29072     } catch (...) {
29073       {
29074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29075       };
29076     }
29077   }
29078
29079   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29085   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29086   Dali::Vector4 *arg2 = 0 ;
29087
29088   arg1 = (Dali::RenderTask *)jarg1;
29089   arg2 = (Dali::Vector4 *)jarg2;
29090   if (!arg2) {
29091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29092     return ;
29093   }
29094   {
29095     try {
29096       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29097     } catch (std::out_of_range& e) {
29098       {
29099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29100       };
29101     } catch (std::exception& e) {
29102       {
29103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29104       };
29105     } catch (Dali::DaliException e) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29108       };
29109     } catch (...) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29112       };
29113     }
29114   }
29115
29116 }
29117
29118
29119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29120   void * jresult ;
29121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29122   Dali::Vector4 result;
29123
29124   arg1 = (Dali::RenderTask *)jarg1;
29125   {
29126     try {
29127       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29128     } catch (std::out_of_range& e) {
29129       {
29130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (std::exception& e) {
29133       {
29134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (Dali::DaliException e) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29139       };
29140     } catch (...) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29143       };
29144     }
29145   }
29146
29147   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29153   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29154   bool arg2 ;
29155
29156   arg1 = (Dali::RenderTask *)jarg1;
29157   arg2 = jarg2 ? true : false;
29158   {
29159     try {
29160       (arg1)->SetClearEnabled(arg2);
29161     } catch (std::out_of_range& e) {
29162       {
29163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29164       };
29165     } catch (std::exception& e) {
29166       {
29167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (Dali::DaliException e) {
29170       {
29171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29172       };
29173     } catch (...) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29176       };
29177     }
29178   }
29179
29180 }
29181
29182
29183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29184   unsigned int jresult ;
29185   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29186   bool result;
29187
29188   arg1 = (Dali::RenderTask *)jarg1;
29189   {
29190     try {
29191       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29192     } catch (std::out_of_range& e) {
29193       {
29194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (std::exception& e) {
29197       {
29198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (Dali::DaliException e) {
29201       {
29202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29203       };
29204     } catch (...) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29207       };
29208     }
29209   }
29210
29211   jresult = result;
29212   return jresult;
29213 }
29214
29215
29216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29217   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29218   bool arg2 ;
29219
29220   arg1 = (Dali::RenderTask *)jarg1;
29221   arg2 = jarg2 ? true : false;
29222   {
29223     try {
29224       (arg1)->SetCullMode(arg2);
29225     } catch (std::out_of_range& e) {
29226       {
29227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29228       };
29229     } catch (std::exception& e) {
29230       {
29231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (Dali::DaliException e) {
29234       {
29235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29236       };
29237     } catch (...) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29240       };
29241     }
29242   }
29243
29244 }
29245
29246
29247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29248   unsigned int jresult ;
29249   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29250   bool result;
29251
29252   arg1 = (Dali::RenderTask *)jarg1;
29253   {
29254     try {
29255       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (Dali::DaliException e) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29267       };
29268     } catch (...) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29271       };
29272     }
29273   }
29274
29275   jresult = result;
29276   return jresult;
29277 }
29278
29279
29280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29281   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29282   unsigned int arg2 ;
29283
29284   arg1 = (Dali::RenderTask *)jarg1;
29285   arg2 = (unsigned int)jarg2;
29286   {
29287     try {
29288       (arg1)->SetRefreshRate(arg2);
29289     } catch (std::out_of_range& e) {
29290       {
29291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29292       };
29293     } catch (std::exception& e) {
29294       {
29295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (Dali::DaliException e) {
29298       {
29299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29300       };
29301     } catch (...) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29304       };
29305     }
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29312   unsigned int jresult ;
29313   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29314   unsigned int result;
29315
29316   arg1 = (Dali::RenderTask *)jarg1;
29317   {
29318     try {
29319       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29320     } catch (std::out_of_range& e) {
29321       {
29322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29323       };
29324     } catch (std::exception& e) {
29325       {
29326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (Dali::DaliException e) {
29329       {
29330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338
29339   jresult = result;
29340   return jresult;
29341 }
29342
29343
29344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29345   unsigned int jresult ;
29346   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29347   Dali::Vector3 *arg2 = 0 ;
29348   float *arg3 = 0 ;
29349   float *arg4 = 0 ;
29350   bool result;
29351
29352   arg1 = (Dali::RenderTask *)jarg1;
29353   arg2 = (Dali::Vector3 *)jarg2;
29354   if (!arg2) {
29355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29356     return 0;
29357   }
29358   arg3 = (float *)jarg3;
29359   arg4 = (float *)jarg4;
29360   {
29361     try {
29362       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29363     } catch (std::out_of_range& e) {
29364       {
29365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29366       };
29367     } catch (std::exception& e) {
29368       {
29369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29370       };
29371     } catch (Dali::DaliException e) {
29372       {
29373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29374       };
29375     } catch (...) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29378       };
29379     }
29380   }
29381
29382   jresult = result;
29383   return jresult;
29384 }
29385
29386
29387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29388   unsigned int jresult ;
29389   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29390   Dali::Actor arg2 ;
29391   float arg3 ;
29392   float arg4 ;
29393   float *arg5 = 0 ;
29394   float *arg6 = 0 ;
29395   Dali::Actor *argp2 ;
29396   bool result;
29397
29398   arg1 = (Dali::RenderTask *)jarg1;
29399   argp2 = (Dali::Actor *)jarg2;
29400   if (!argp2) {
29401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29402     return 0;
29403   }
29404   arg2 = *argp2;
29405   arg3 = (float)jarg3;
29406   arg4 = (float)jarg4;
29407   arg5 = (float *)jarg5;
29408   arg6 = (float *)jarg6;
29409   {
29410     try {
29411       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29412     } catch (std::out_of_range& e) {
29413       {
29414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29415       };
29416     } catch (std::exception& e) {
29417       {
29418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29419       };
29420     } catch (Dali::DaliException e) {
29421       {
29422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29423       };
29424     } catch (...) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29427       };
29428     }
29429   }
29430
29431   jresult = result;
29432   return jresult;
29433 }
29434
29435
29436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29437   void * jresult ;
29438   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29439   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29440
29441   arg1 = (Dali::RenderTask *)jarg1;
29442   {
29443     try {
29444       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29445     } catch (std::out_of_range& e) {
29446       {
29447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (std::exception& e) {
29450       {
29451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (Dali::DaliException e) {
29454       {
29455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29456       };
29457     } catch (...) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29460       };
29461     }
29462   }
29463
29464   jresult = (void *)result;
29465   return jresult;
29466 }
29467
29468
29469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29470   void * jresult ;
29471   int arg1 ;
29472   Dali::TouchPoint::State arg2 ;
29473   float arg3 ;
29474   float arg4 ;
29475   Dali::TouchPoint *result = 0 ;
29476
29477   arg1 = (int)jarg1;
29478   arg2 = (Dali::TouchPoint::State)jarg2;
29479   arg3 = (float)jarg3;
29480   arg4 = (float)jarg4;
29481   {
29482     try {
29483       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29484     } catch (std::out_of_range& e) {
29485       {
29486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29487       };
29488     } catch (std::exception& e) {
29489       {
29490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29491       };
29492     } catch (Dali::DaliException e) {
29493       {
29494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29495       };
29496     } catch (...) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29499       };
29500     }
29501   }
29502
29503   jresult = (void *)result;
29504   return jresult;
29505 }
29506
29507
29508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29509   void * jresult ;
29510   int arg1 ;
29511   Dali::TouchPoint::State arg2 ;
29512   float arg3 ;
29513   float arg4 ;
29514   float arg5 ;
29515   float arg6 ;
29516   Dali::TouchPoint *result = 0 ;
29517
29518   arg1 = (int)jarg1;
29519   arg2 = (Dali::TouchPoint::State)jarg2;
29520   arg3 = (float)jarg3;
29521   arg4 = (float)jarg4;
29522   arg5 = (float)jarg5;
29523   arg6 = (float)jarg6;
29524   {
29525     try {
29526       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29527     } catch (std::out_of_range& e) {
29528       {
29529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29530       };
29531     } catch (std::exception& e) {
29532       {
29533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (Dali::DaliException e) {
29536       {
29537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29538       };
29539     } catch (...) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29542       };
29543     }
29544   }
29545
29546   jresult = (void *)result;
29547   return jresult;
29548 }
29549
29550
29551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29552   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29553
29554   arg1 = (Dali::TouchPoint *)jarg1;
29555   {
29556     try {
29557       delete arg1;
29558     } catch (std::out_of_range& e) {
29559       {
29560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29561       };
29562     } catch (std::exception& e) {
29563       {
29564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29565       };
29566     } catch (Dali::DaliException e) {
29567       {
29568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29569       };
29570     } catch (...) {
29571       {
29572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29573       };
29574     }
29575   }
29576
29577 }
29578
29579
29580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29581   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29582   int arg2 ;
29583
29584   arg1 = (Dali::TouchPoint *)jarg1;
29585   arg2 = (int)jarg2;
29586   if (arg1) (arg1)->deviceId = arg2;
29587 }
29588
29589
29590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29591   int jresult ;
29592   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29593   int result;
29594
29595   arg1 = (Dali::TouchPoint *)jarg1;
29596   result = (int) ((arg1)->deviceId);
29597   jresult = result;
29598   return jresult;
29599 }
29600
29601
29602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29603   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29604   Dali::TouchPoint::State arg2 ;
29605
29606   arg1 = (Dali::TouchPoint *)jarg1;
29607   arg2 = (Dali::TouchPoint::State)jarg2;
29608   if (arg1) (arg1)->state = arg2;
29609 }
29610
29611
29612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29613   int jresult ;
29614   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29615   Dali::TouchPoint::State result;
29616
29617   arg1 = (Dali::TouchPoint *)jarg1;
29618   result = (Dali::TouchPoint::State) ((arg1)->state);
29619   jresult = (int)result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29625   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29626   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29627
29628   arg1 = (Dali::TouchPoint *)jarg1;
29629   arg2 = (Dali::Actor *)jarg2;
29630   if (arg1) (arg1)->hitActor = *arg2;
29631 }
29632
29633
29634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29635   void * jresult ;
29636   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29637   Dali::Actor *result = 0 ;
29638
29639   arg1 = (Dali::TouchPoint *)jarg1;
29640   result = (Dali::Actor *)& ((arg1)->hitActor);
29641   jresult = (void *)result;
29642   return jresult;
29643 }
29644
29645
29646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29647   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29648   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29649
29650   arg1 = (Dali::TouchPoint *)jarg1;
29651   arg2 = (Dali::Vector2 *)jarg2;
29652   if (arg1) (arg1)->local = *arg2;
29653 }
29654
29655
29656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29657   void * jresult ;
29658   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29659   Dali::Vector2 *result = 0 ;
29660
29661   arg1 = (Dali::TouchPoint *)jarg1;
29662   result = (Dali::Vector2 *)& ((arg1)->local);
29663   jresult = (void *)result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29669   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29670   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29671
29672   arg1 = (Dali::TouchPoint *)jarg1;
29673   arg2 = (Dali::Vector2 *)jarg2;
29674   if (arg1) (arg1)->screen = *arg2;
29675 }
29676
29677
29678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29679   void * jresult ;
29680   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29681   Dali::Vector2 *result = 0 ;
29682
29683   arg1 = (Dali::TouchPoint *)jarg1;
29684   result = (Dali::Vector2 *)& ((arg1)->screen);
29685   jresult = (void *)result;
29686   return jresult;
29687 }
29688
29689
29690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29691   void * jresult ;
29692   Dali::TouchData *result = 0 ;
29693
29694   {
29695     try {
29696       result = (Dali::TouchData *)new Dali::TouchData();
29697     } catch (std::out_of_range& e) {
29698       {
29699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29700       };
29701     } catch (std::exception& e) {
29702       {
29703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (Dali::DaliException e) {
29706       {
29707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29708       };
29709     } catch (...) {
29710       {
29711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29712       };
29713     }
29714   }
29715
29716   jresult = (void *)result;
29717   return jresult;
29718 }
29719
29720
29721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29722   void * jresult ;
29723   Dali::TouchData *arg1 = 0 ;
29724   Dali::TouchData *result = 0 ;
29725
29726   arg1 = (Dali::TouchData *)jarg1;
29727   if (!arg1) {
29728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29729     return 0;
29730   }
29731   {
29732     try {
29733       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29734     } catch (std::out_of_range& e) {
29735       {
29736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29737       };
29738     } catch (std::exception& e) {
29739       {
29740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (Dali::DaliException e) {
29743       {
29744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29745       };
29746     } catch (...) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29749       };
29750     }
29751   }
29752
29753   jresult = (void *)result;
29754   return jresult;
29755 }
29756
29757
29758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29759   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29760
29761   arg1 = (Dali::TouchData *)jarg1;
29762   {
29763     try {
29764       delete arg1;
29765     } catch (std::out_of_range& e) {
29766       {
29767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29768       };
29769     } catch (std::exception& e) {
29770       {
29771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29772       };
29773     } catch (Dali::DaliException e) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29776       };
29777     } catch (...) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29780       };
29781     }
29782   }
29783
29784 }
29785
29786
29787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29788   void * jresult ;
29789   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29790   Dali::TouchData *arg2 = 0 ;
29791   Dali::TouchData *result = 0 ;
29792
29793   arg1 = (Dali::TouchData *)jarg1;
29794   arg2 = (Dali::TouchData *)jarg2;
29795   if (!arg2) {
29796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29797     return 0;
29798   }
29799   {
29800     try {
29801       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29802     } catch (std::out_of_range& e) {
29803       {
29804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29805       };
29806     } catch (std::exception& e) {
29807       {
29808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29809       };
29810     } catch (Dali::DaliException e) {
29811       {
29812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29813       };
29814     } catch (...) {
29815       {
29816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29817       };
29818     }
29819   }
29820
29821   jresult = (void *)result;
29822   return jresult;
29823 }
29824
29825
29826 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29827   unsigned long jresult ;
29828   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29829   unsigned long result;
29830
29831   arg1 = (Dali::TouchData *)jarg1;
29832   {
29833     try {
29834       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29835     } catch (std::out_of_range& e) {
29836       {
29837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29838       };
29839     } catch (std::exception& e) {
29840       {
29841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29842       };
29843     } catch (Dali::DaliException e) {
29844       {
29845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29846       };
29847     } catch (...) {
29848       {
29849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29850       };
29851     }
29852   }
29853
29854   jresult = (unsigned long)result;
29855   return jresult;
29856 }
29857
29858
29859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29860   unsigned long jresult ;
29861   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29862   std::size_t result;
29863
29864   arg1 = (Dali::TouchData *)jarg1;
29865   {
29866     try {
29867       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29868     } catch (std::out_of_range& e) {
29869       {
29870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (std::exception& e) {
29873       {
29874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (Dali::DaliException e) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29879       };
29880     } catch (...) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29883       };
29884     }
29885   }
29886
29887   jresult = (unsigned long)result;
29888   return jresult;
29889 }
29890
29891
29892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29893   int jresult ;
29894   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29895   std::size_t arg2 ;
29896   int32_t result;
29897
29898   arg1 = (Dali::TouchData *)jarg1;
29899   arg2 = (std::size_t)jarg2;
29900   {
29901     try {
29902       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29903     } catch (std::out_of_range& e) {
29904       {
29905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (std::exception& e) {
29908       {
29909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29910       };
29911     } catch (Dali::DaliException e) {
29912       {
29913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29914       };
29915     } catch (...) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29918       };
29919     }
29920   }
29921
29922   jresult = result;
29923   return jresult;
29924 }
29925
29926
29927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29928   int jresult ;
29929   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29930   std::size_t arg2 ;
29931   Dali::PointState::Type result;
29932
29933   arg1 = (Dali::TouchData *)jarg1;
29934   arg2 = (std::size_t)jarg2;
29935   {
29936     try {
29937       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29938     } catch (std::out_of_range& e) {
29939       {
29940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29941       };
29942     } catch (std::exception& e) {
29943       {
29944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29945       };
29946     } catch (Dali::DaliException e) {
29947       {
29948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29949       };
29950     } catch (...) {
29951       {
29952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29953       };
29954     }
29955   }
29956
29957   jresult = (int)result;
29958   return jresult;
29959 }
29960
29961
29962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29963   void * jresult ;
29964   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29965   std::size_t arg2 ;
29966   Dali::Actor result;
29967
29968   arg1 = (Dali::TouchData *)jarg1;
29969   arg2 = (std::size_t)jarg2;
29970   {
29971     try {
29972       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29973     } catch (std::out_of_range& e) {
29974       {
29975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29976       };
29977     } catch (std::exception& e) {
29978       {
29979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (Dali::DaliException e) {
29982       {
29983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29984       };
29985     } catch (...) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29988       };
29989     }
29990   }
29991
29992   jresult = new Dali::Actor((const Dali::Actor &)result);
29993   return jresult;
29994 }
29995
29996
29997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29998   void * jresult ;
29999   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30000   std::size_t arg2 ;
30001   Dali::Vector2 *result = 0 ;
30002
30003   arg1 = (Dali::TouchData *)jarg1;
30004   arg2 = (std::size_t)jarg2;
30005   {
30006     try {
30007       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30008     } catch (std::out_of_range& e) {
30009       {
30010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30011       };
30012     } catch (std::exception& e) {
30013       {
30014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (Dali::DaliException e) {
30017       {
30018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30019       };
30020     } catch (...) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30023       };
30024     }
30025   }
30026
30027   jresult = (void *)result;
30028   return jresult;
30029 }
30030
30031
30032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30033   void * jresult ;
30034   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30035   std::size_t arg2 ;
30036   Dali::Vector2 *result = 0 ;
30037
30038   arg1 = (Dali::TouchData *)jarg1;
30039   arg2 = (std::size_t)jarg2;
30040   {
30041     try {
30042       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30043     } catch (std::out_of_range& e) {
30044       {
30045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30046       };
30047     } catch (std::exception& e) {
30048       {
30049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (Dali::DaliException e) {
30052       {
30053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30054       };
30055     } catch (...) {
30056       {
30057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30058       };
30059     }
30060   }
30061
30062   jresult = (void *)result;
30063   return jresult;
30064 }
30065
30066
30067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30068   float jresult ;
30069   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30070   std::size_t arg2 ;
30071   float result;
30072
30073   arg1 = (Dali::TouchData *)jarg1;
30074   arg2 = (std::size_t)jarg2;
30075   {
30076     try {
30077       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30078     } catch (std::out_of_range& e) {
30079       {
30080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30081       };
30082     } catch (std::exception& e) {
30083       {
30084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (Dali::DaliException e) {
30087       {
30088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30089       };
30090     } catch (...) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30093       };
30094     }
30095   }
30096
30097   jresult = result;
30098   return jresult;
30099 }
30100
30101
30102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30103   void * jresult ;
30104   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30105   std::size_t arg2 ;
30106   Dali::Vector2 *result = 0 ;
30107
30108   arg1 = (Dali::TouchData *)jarg1;
30109   arg2 = (std::size_t)jarg2;
30110   {
30111     try {
30112       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30113     } catch (std::out_of_range& e) {
30114       {
30115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30116       };
30117     } catch (std::exception& e) {
30118       {
30119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30120       };
30121     } catch (Dali::DaliException e) {
30122       {
30123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30124       };
30125     } catch (...) {
30126       {
30127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30128       };
30129     }
30130   }
30131
30132   jresult = (void *)result;
30133   return jresult;
30134 }
30135
30136
30137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30138   float jresult ;
30139   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30140   std::size_t arg2 ;
30141   float result;
30142
30143   arg1 = (Dali::TouchData *)jarg1;
30144   arg2 = (std::size_t)jarg2;
30145   {
30146     try {
30147       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30148     } catch (std::out_of_range& e) {
30149       {
30150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30151       };
30152     } catch (std::exception& e) {
30153       {
30154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30155       };
30156     } catch (Dali::DaliException e) {
30157       {
30158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30159       };
30160     } catch (...) {
30161       {
30162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30163       };
30164     }
30165   }
30166
30167   jresult = result;
30168   return jresult;
30169 }
30170
30171
30172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30173   void * jresult ;
30174   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30175   std::size_t arg2 ;
30176   Dali::Degree result;
30177
30178   arg1 = (Dali::TouchData *)jarg1;
30179   arg2 = (std::size_t)jarg2;
30180   {
30181     try {
30182       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30183     } catch (std::out_of_range& e) {
30184       {
30185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30186       };
30187     } catch (std::exception& e) {
30188       {
30189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (Dali::DaliException e) {
30192       {
30193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30194       };
30195     } catch (...) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30198       };
30199     }
30200   }
30201
30202   jresult = new Dali::Degree((const Dali::Degree &)result);
30203   return jresult;
30204 }
30205
30206
30207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30208   int jresult ;
30209   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30210   std::size_t arg2 ;
30211   Dali::MouseButton::Type result;
30212
30213   arg1 = (Dali::TouchData *)jarg1;
30214   arg2 = (std::size_t)jarg2;
30215   {
30216     try {
30217       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30218     } catch (std::out_of_range& e) {
30219       {
30220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30221       };
30222     } catch (std::exception& e) {
30223       {
30224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30225       };
30226     } catch (Dali::DaliException e) {
30227       {
30228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30229       };
30230     } catch (...) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30233       };
30234     }
30235   }
30236
30237   jresult = static_cast< int >(result);
30238   return jresult;
30239 }
30240
30241
30242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30243   void * jresult ;
30244   Dali::GestureDetector *result = 0 ;
30245
30246   {
30247     try {
30248       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30249     } catch (std::out_of_range& e) {
30250       {
30251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30252       };
30253     } catch (std::exception& e) {
30254       {
30255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (Dali::DaliException e) {
30258       {
30259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30260       };
30261     } catch (...) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30264       };
30265     }
30266   }
30267
30268   jresult = (void *)result;
30269   return jresult;
30270 }
30271
30272
30273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30274   void * jresult ;
30275   Dali::BaseHandle arg1 ;
30276   Dali::BaseHandle *argp1 ;
30277   Dali::GestureDetector result;
30278
30279   argp1 = (Dali::BaseHandle *)jarg1;
30280   if (!argp1) {
30281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30282     return 0;
30283   }
30284   arg1 = *argp1;
30285   {
30286     try {
30287       result = Dali::GestureDetector::DownCast(arg1);
30288     } catch (std::out_of_range& e) {
30289       {
30290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30291       };
30292     } catch (std::exception& e) {
30293       {
30294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (Dali::DaliException e) {
30297       {
30298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30299       };
30300     } catch (...) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30303       };
30304     }
30305   }
30306
30307   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30308   return jresult;
30309 }
30310
30311
30312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30313   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30314
30315   arg1 = (Dali::GestureDetector *)jarg1;
30316   {
30317     try {
30318       delete arg1;
30319     } catch (std::out_of_range& e) {
30320       {
30321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30322       };
30323     } catch (std::exception& e) {
30324       {
30325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (Dali::DaliException e) {
30328       {
30329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30334       };
30335     }
30336   }
30337
30338 }
30339
30340
30341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30342   void * jresult ;
30343   Dali::GestureDetector *arg1 = 0 ;
30344   Dali::GestureDetector *result = 0 ;
30345
30346   arg1 = (Dali::GestureDetector *)jarg1;
30347   if (!arg1) {
30348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30349     return 0;
30350   }
30351   {
30352     try {
30353       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30354     } catch (std::out_of_range& e) {
30355       {
30356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30357       };
30358     } catch (std::exception& e) {
30359       {
30360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (Dali::DaliException e) {
30363       {
30364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30365       };
30366     } catch (...) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30369       };
30370     }
30371   }
30372
30373   jresult = (void *)result;
30374   return jresult;
30375 }
30376
30377
30378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30379   void * jresult ;
30380   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30381   Dali::GestureDetector *arg2 = 0 ;
30382   Dali::GestureDetector *result = 0 ;
30383
30384   arg1 = (Dali::GestureDetector *)jarg1;
30385   arg2 = (Dali::GestureDetector *)jarg2;
30386   if (!arg2) {
30387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30388     return 0;
30389   }
30390   {
30391     try {
30392       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30393     } catch (std::out_of_range& e) {
30394       {
30395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30396       };
30397     } catch (std::exception& e) {
30398       {
30399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30400       };
30401     } catch (Dali::DaliException e) {
30402       {
30403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30404       };
30405     } catch (...) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30408       };
30409     }
30410   }
30411
30412   jresult = (void *)result;
30413   return jresult;
30414 }
30415
30416
30417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30418   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30419   Dali::Actor arg2 ;
30420   Dali::Actor *argp2 ;
30421
30422   arg1 = (Dali::GestureDetector *)jarg1;
30423   argp2 = (Dali::Actor *)jarg2;
30424   if (!argp2) {
30425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30426     return ;
30427   }
30428   arg2 = *argp2;
30429   {
30430     try {
30431       (arg1)->Attach(arg2);
30432     } catch (std::out_of_range& e) {
30433       {
30434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30435       };
30436     } catch (std::exception& e) {
30437       {
30438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (Dali::DaliException e) {
30441       {
30442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30443       };
30444     } catch (...) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30447       };
30448     }
30449   }
30450
30451 }
30452
30453
30454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30455   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30456   Dali::Actor arg2 ;
30457   Dali::Actor *argp2 ;
30458
30459   arg1 = (Dali::GestureDetector *)jarg1;
30460   argp2 = (Dali::Actor *)jarg2;
30461   if (!argp2) {
30462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30463     return ;
30464   }
30465   arg2 = *argp2;
30466   {
30467     try {
30468       (arg1)->Detach(arg2);
30469     } catch (std::out_of_range& e) {
30470       {
30471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30472       };
30473     } catch (std::exception& e) {
30474       {
30475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (Dali::DaliException e) {
30478       {
30479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30480       };
30481     } catch (...) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30484       };
30485     }
30486   }
30487
30488 }
30489
30490
30491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30492   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30493
30494   arg1 = (Dali::GestureDetector *)jarg1;
30495   {
30496     try {
30497       (arg1)->DetachAll();
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30513       };
30514     }
30515   }
30516
30517 }
30518
30519
30520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30521   unsigned long jresult ;
30522   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30523   size_t result;
30524
30525   arg1 = (Dali::GestureDetector *)jarg1;
30526   {
30527     try {
30528       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30529     } catch (std::out_of_range& e) {
30530       {
30531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30532       };
30533     } catch (std::exception& e) {
30534       {
30535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (Dali::DaliException e) {
30538       {
30539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30540       };
30541     } catch (...) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30544       };
30545     }
30546   }
30547
30548   jresult = (unsigned long)result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30554   void * jresult ;
30555   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30556   size_t arg2 ;
30557   Dali::Actor result;
30558
30559   arg1 = (Dali::GestureDetector *)jarg1;
30560   arg2 = (size_t)jarg2;
30561   {
30562     try {
30563       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30564     } catch (std::out_of_range& e) {
30565       {
30566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30567       };
30568     } catch (std::exception& e) {
30569       {
30570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (Dali::DaliException e) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30575       };
30576     } catch (...) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30579       };
30580     }
30581   }
30582
30583   jresult = new Dali::Actor((const Dali::Actor &)result);
30584   return jresult;
30585 }
30586
30587
30588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30589   void * jresult ;
30590   Dali::Gesture *arg1 = 0 ;
30591   Dali::Gesture *result = 0 ;
30592
30593   arg1 = (Dali::Gesture *)jarg1;
30594   if (!arg1) {
30595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30596     return 0;
30597   }
30598   {
30599     try {
30600       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30601     } catch (std::out_of_range& e) {
30602       {
30603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30604       };
30605     } catch (std::exception& e) {
30606       {
30607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30608       };
30609     } catch (Dali::DaliException e) {
30610       {
30611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30612       };
30613     } catch (...) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30616       };
30617     }
30618   }
30619
30620   jresult = (void *)result;
30621   return jresult;
30622 }
30623
30624
30625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30626   void * jresult ;
30627   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30628   Dali::Gesture *arg2 = 0 ;
30629   Dali::Gesture *result = 0 ;
30630
30631   arg1 = (Dali::Gesture *)jarg1;
30632   arg2 = (Dali::Gesture *)jarg2;
30633   if (!arg2) {
30634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30635     return 0;
30636   }
30637   {
30638     try {
30639       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30640     } catch (std::out_of_range& e) {
30641       {
30642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30643       };
30644     } catch (std::exception& e) {
30645       {
30646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30647       };
30648     } catch (Dali::DaliException e) {
30649       {
30650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30651       };
30652     } catch (...) {
30653       {
30654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30655       };
30656     }
30657   }
30658
30659   jresult = (void *)result;
30660   return jresult;
30661 }
30662
30663
30664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30665   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30666
30667   arg1 = (Dali::Gesture *)jarg1;
30668   {
30669     try {
30670       delete arg1;
30671     } catch (std::out_of_range& e) {
30672       {
30673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30674       };
30675     } catch (std::exception& e) {
30676       {
30677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30678       };
30679     } catch (Dali::DaliException e) {
30680       {
30681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30682       };
30683     } catch (...) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30686       };
30687     }
30688   }
30689
30690 }
30691
30692
30693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30694   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30695   Dali::Gesture::Type arg2 ;
30696
30697   arg1 = (Dali::Gesture *)jarg1;
30698   arg2 = (Dali::Gesture::Type)jarg2;
30699   if (arg1) (arg1)->type = arg2;
30700 }
30701
30702
30703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30704   int jresult ;
30705   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30706   Dali::Gesture::Type result;
30707
30708   arg1 = (Dali::Gesture *)jarg1;
30709   result = (Dali::Gesture::Type) ((arg1)->type);
30710   jresult = (int)result;
30711   return jresult;
30712 }
30713
30714
30715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30716   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30717   Dali::Gesture::State arg2 ;
30718
30719   arg1 = (Dali::Gesture *)jarg1;
30720   arg2 = (Dali::Gesture::State)jarg2;
30721   if (arg1) (arg1)->state = arg2;
30722 }
30723
30724
30725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30726   int jresult ;
30727   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30728   Dali::Gesture::State result;
30729
30730   arg1 = (Dali::Gesture *)jarg1;
30731   result = (Dali::Gesture::State) ((arg1)->state);
30732   jresult = (int)result;
30733   return jresult;
30734 }
30735
30736
30737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30738   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30739   unsigned int arg2 ;
30740
30741   arg1 = (Dali::Gesture *)jarg1;
30742   arg2 = (unsigned int)jarg2;
30743   if (arg1) (arg1)->time = arg2;
30744 }
30745
30746
30747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30748   unsigned int jresult ;
30749   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30750   unsigned int result;
30751
30752   arg1 = (Dali::Gesture *)jarg1;
30753   result = (unsigned int) ((arg1)->time);
30754   jresult = result;
30755   return jresult;
30756 }
30757
30758
30759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30760   void * jresult ;
30761   Dali::HoverEvent *result = 0 ;
30762
30763   {
30764     try {
30765       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30766     } catch (std::out_of_range& e) {
30767       {
30768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30769       };
30770     } catch (std::exception& e) {
30771       {
30772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (Dali::DaliException e) {
30775       {
30776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30777       };
30778     } catch (...) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30781       };
30782     }
30783   }
30784
30785   jresult = (void *)result;
30786   return jresult;
30787 }
30788
30789
30790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30791   void * jresult ;
30792   unsigned long arg1 ;
30793   Dali::HoverEvent *result = 0 ;
30794
30795   arg1 = (unsigned long)jarg1;
30796   {
30797     try {
30798       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30799     } catch (std::out_of_range& e) {
30800       {
30801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30802       };
30803     } catch (std::exception& e) {
30804       {
30805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30806       };
30807     } catch (Dali::DaliException e) {
30808       {
30809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30814       };
30815     }
30816   }
30817
30818   jresult = (void *)result;
30819   return jresult;
30820 }
30821
30822
30823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30824   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30825
30826   arg1 = (Dali::HoverEvent *)jarg1;
30827   {
30828     try {
30829       delete arg1;
30830     } catch (std::out_of_range& e) {
30831       {
30832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30833       };
30834     } catch (std::exception& e) {
30835       {
30836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30837       };
30838     } catch (Dali::DaliException e) {
30839       {
30840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30841       };
30842     } catch (...) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30845       };
30846     }
30847   }
30848
30849 }
30850
30851
30852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30853   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30854   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30855
30856   arg1 = (Dali::HoverEvent *)jarg1;
30857   arg2 = (Dali::TouchPointContainer *)jarg2;
30858   if (arg1) (arg1)->points = *arg2;
30859 }
30860
30861
30862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30863   void * jresult ;
30864   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30865   Dali::TouchPointContainer *result = 0 ;
30866
30867   arg1 = (Dali::HoverEvent *)jarg1;
30868   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30869   jresult = (void *)result;
30870   return jresult;
30871 }
30872
30873
30874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30875   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30876   unsigned long arg2 ;
30877
30878   arg1 = (Dali::HoverEvent *)jarg1;
30879   arg2 = (unsigned long)jarg2;
30880   if (arg1) (arg1)->time = arg2;
30881 }
30882
30883
30884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30885   unsigned long jresult ;
30886   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30887   unsigned long result;
30888
30889   arg1 = (Dali::HoverEvent *)jarg1;
30890   result = (unsigned long) ((arg1)->time);
30891   jresult = (unsigned long)result;
30892   return jresult;
30893 }
30894
30895
30896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30897   unsigned int jresult ;
30898   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30899   unsigned int result;
30900
30901   arg1 = (Dali::HoverEvent *)jarg1;
30902   {
30903     try {
30904       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30905     } catch (std::out_of_range& e) {
30906       {
30907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30908       };
30909     } catch (std::exception& e) {
30910       {
30911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (Dali::DaliException e) {
30914       {
30915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30916       };
30917     } catch (...) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30920       };
30921     }
30922   }
30923
30924   jresult = result;
30925   return jresult;
30926 }
30927
30928
30929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30930   void * jresult ;
30931   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30932   unsigned int arg2 ;
30933   Dali::TouchPoint *result = 0 ;
30934
30935   arg1 = (Dali::HoverEvent *)jarg1;
30936   arg2 = (unsigned int)jarg2;
30937   {
30938     try {
30939       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30940     } catch (std::out_of_range& e) {
30941       {
30942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30943       };
30944     } catch (std::exception& e) {
30945       {
30946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (Dali::DaliException e) {
30949       {
30950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30951       };
30952     } catch (...) {
30953       {
30954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30955       };
30956     }
30957   }
30958
30959   jresult = (void *)result;
30960   return jresult;
30961 }
30962
30963
30964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30965   void * jresult ;
30966   Dali::KeyEvent *result = 0 ;
30967
30968   {
30969     try {
30970       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30971     } catch (std::out_of_range& e) {
30972       {
30973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (std::exception& e) {
30976       {
30977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (Dali::DaliException e) {
30980       {
30981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30982       };
30983     } catch (...) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30986       };
30987     }
30988   }
30989
30990   jresult = (void *)result;
30991   return jresult;
30992 }
30993
30994
30995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30996   void * jresult ;
30997   std::string *arg1 = 0 ;
30998   std::string *arg2 = 0 ;
30999   int arg3 ;
31000   int arg4 ;
31001   unsigned long arg5 ;
31002   Dali::KeyEvent::State *arg6 = 0 ;
31003   Dali::KeyEvent::State temp6 ;
31004   Dali::KeyEvent *result = 0 ;
31005
31006   if (!jarg1) {
31007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31008     return 0;
31009   }
31010   std::string arg1_str(jarg1);
31011   arg1 = &arg1_str;
31012   if (!jarg2) {
31013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31014     return 0;
31015   }
31016   std::string arg2_str(jarg2);
31017   arg2 = &arg2_str;
31018   arg3 = (int)jarg3;
31019   arg4 = (int)jarg4;
31020   arg5 = (unsigned long)jarg5;
31021   temp6 = (Dali::KeyEvent::State)jarg6;
31022   arg6 = &temp6;
31023   {
31024     try {
31025       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31026     } catch (std::out_of_range& e) {
31027       {
31028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31029       };
31030     } catch (std::exception& e) {
31031       {
31032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (Dali::DaliException e) {
31035       {
31036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31037       };
31038     } catch (...) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31041       };
31042     }
31043   }
31044
31045   jresult = (void *)result;
31046
31047   //argout typemap for const std::string&
31048
31049
31050   //argout typemap for const std::string&
31051
31052   return jresult;
31053 }
31054
31055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31056   void * jresult ;
31057   Dali::KeyEvent *arg1 = 0 ;
31058   Dali::KeyEvent *result = 0 ;
31059
31060   arg1 = (Dali::KeyEvent *)jarg1;
31061   if (!arg1) {
31062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31063     return 0;
31064   }
31065   {
31066     try {
31067       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31068     } catch (std::out_of_range& e) {
31069       {
31070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (std::exception& e) {
31073       {
31074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (Dali::DaliException e) {
31077       {
31078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31079       };
31080     } catch (...) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31083       };
31084     }
31085   }
31086
31087   jresult = (void *)result;
31088   return jresult;
31089 }
31090
31091
31092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31093   void * jresult ;
31094   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31095   Dali::KeyEvent *arg2 = 0 ;
31096   Dali::KeyEvent *result = 0 ;
31097
31098   arg1 = (Dali::KeyEvent *)jarg1;
31099   arg2 = (Dali::KeyEvent *)jarg2;
31100   if (!arg2) {
31101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31102     return 0;
31103   }
31104   {
31105     try {
31106       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31107     } catch (std::out_of_range& e) {
31108       {
31109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31110       };
31111     } catch (std::exception& e) {
31112       {
31113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (Dali::DaliException e) {
31116       {
31117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125
31126   jresult = (void *)result;
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31132   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31133
31134   arg1 = (Dali::KeyEvent *)jarg1;
31135   {
31136     try {
31137       delete arg1;
31138     } catch (std::out_of_range& e) {
31139       {
31140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31141       };
31142     } catch (std::exception& e) {
31143       {
31144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31145       };
31146     } catch (Dali::DaliException e) {
31147       {
31148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31149       };
31150     } catch (...) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31153       };
31154     }
31155   }
31156
31157 }
31158
31159
31160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31161   unsigned int jresult ;
31162   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31163   bool result;
31164
31165   arg1 = (Dali::KeyEvent *)jarg1;
31166   {
31167     try {
31168       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31169     } catch (std::out_of_range& e) {
31170       {
31171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (std::exception& e) {
31174       {
31175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (Dali::DaliException e) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31180       };
31181     } catch (...) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31184       };
31185     }
31186   }
31187
31188   jresult = result;
31189   return jresult;
31190 }
31191
31192
31193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31194   unsigned int jresult ;
31195   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31196   bool result;
31197
31198   arg1 = (Dali::KeyEvent *)jarg1;
31199   {
31200     try {
31201       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31202     } catch (std::out_of_range& e) {
31203       {
31204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (std::exception& e) {
31207       {
31208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (Dali::DaliException e) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31213       };
31214     } catch (...) {
31215       {
31216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31217       };
31218     }
31219   }
31220
31221   jresult = result;
31222   return jresult;
31223 }
31224
31225
31226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31227   unsigned int jresult ;
31228   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31229   bool result;
31230
31231   arg1 = (Dali::KeyEvent *)jarg1;
31232   {
31233     try {
31234       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (Dali::DaliException e) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31250       };
31251     }
31252   }
31253
31254   jresult = result;
31255   return jresult;
31256 }
31257
31258
31259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31260   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31261   std::string *arg2 = 0 ;
31262
31263   arg1 = (Dali::KeyEvent *)jarg1;
31264   if (!jarg2) {
31265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31266     return ;
31267   }
31268   std::string arg2_str(jarg2);
31269   arg2 = &arg2_str;
31270   if (arg1) (arg1)->keyPressedName = *arg2;
31271
31272   //argout typemap for const std::string&
31273
31274 }
31275
31276
31277 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31278   char * jresult ;
31279
31280   if( jarg1 == NULL )
31281   {
31282     jresult = SWIG_csharp_string_callback( "" );
31283   }
31284   else
31285   {
31286     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31287     std::string *result = 0;
31288
31289     arg1 = ( Dali::KeyEvent * )jarg1;
31290     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31291     jresult = SWIG_csharp_string_callback( result->c_str() );
31292   }
31293
31294   return jresult;
31295 }
31296
31297
31298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31299   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31300   std::string *arg2 = 0 ;
31301
31302   arg1 = (Dali::KeyEvent *)jarg1;
31303   if (!jarg2) {
31304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31305     return ;
31306   }
31307   std::string arg2_str(jarg2);
31308   arg2 = &arg2_str;
31309   if (arg1) (arg1)->keyPressed = *arg2;
31310
31311   //argout typemap for const std::string&
31312
31313 }
31314
31315
31316 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31317   char * jresult ;
31318   if( NULL == jarg1 )
31319   {
31320     jresult = SWIG_csharp_string_callback( "" );
31321   }
31322   else
31323   {
31324     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31325     std::string *result = 0;
31326
31327     arg1 = ( Dali::KeyEvent * )jarg1;
31328     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31329     jresult = SWIG_csharp_string_callback( result->c_str() );
31330   }
31331   return jresult;
31332 }
31333
31334
31335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31336   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31337   int arg2 ;
31338
31339   arg1 = (Dali::KeyEvent *)jarg1;
31340   arg2 = (int)jarg2;
31341   if (arg1) (arg1)->keyCode = arg2;
31342 }
31343
31344
31345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31346   int jresult ;
31347   if( NULL == jarg1 )
31348   {
31349     jresult = -1;
31350   }
31351   else
31352   {
31353     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31354     int result;
31355
31356     arg1 = ( Dali::KeyEvent * )jarg1;
31357     result = (int)( ( arg1 )->keyCode );
31358     jresult = result;
31359   }
31360   return jresult;
31361 }
31362
31363
31364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31366   int arg2 ;
31367
31368   arg1 = (Dali::KeyEvent *)jarg1;
31369   arg2 = (int)jarg2;
31370   if (arg1) (arg1)->keyModifier = arg2;
31371 }
31372
31373
31374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31375   int jresult ;
31376   if( jarg1 == NULL )
31377   {
31378     jresult = -1;
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     int result;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = (int)( ( arg1 )->keyModifier );
31387     jresult = result;
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   unsigned long arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (unsigned long)jarg2;
31399   if (arg1) (arg1)->time = arg2;
31400 }
31401
31402
31403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31404   unsigned long jresult ;
31405   if( jarg1 == NULL )
31406   {
31407     jresult = 0;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     unsigned long result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (unsigned long)( ( arg1 )->time );
31416     jresult = (unsigned long)result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   Dali::KeyEvent::State arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (Dali::KeyEvent::State)jarg2;
31428   if (arg1) (arg1)->state = arg2;
31429 }
31430
31431
31432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31433   int jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = -1;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     Dali::KeyEvent::State result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31445     jresult = (int)result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31452   void * jresult ;
31453   Dali::LongPressGestureDetector *result = 0 ;
31454
31455   {
31456     try {
31457       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31458     } catch (std::out_of_range& e) {
31459       {
31460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31461       };
31462     } catch (std::exception& e) {
31463       {
31464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (Dali::DaliException e) {
31467       {
31468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31469       };
31470     } catch (...) {
31471       {
31472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31473       };
31474     }
31475   }
31476
31477   jresult = (void *)result;
31478   return jresult;
31479 }
31480
31481
31482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31483   void * jresult ;
31484   Dali::LongPressGestureDetector result;
31485
31486   {
31487     try {
31488       result = Dali::LongPressGestureDetector::New();
31489     } catch (std::out_of_range& e) {
31490       {
31491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31492       };
31493     } catch (std::exception& e) {
31494       {
31495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (Dali::DaliException e) {
31498       {
31499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31500       };
31501     } catch (...) {
31502       {
31503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31504       };
31505     }
31506   }
31507
31508   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31509   return jresult;
31510 }
31511
31512
31513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31514   void * jresult ;
31515   unsigned int arg1 ;
31516   Dali::LongPressGestureDetector result;
31517
31518   arg1 = (unsigned int)jarg1;
31519   {
31520     try {
31521       result = Dali::LongPressGestureDetector::New(arg1);
31522     } catch (std::out_of_range& e) {
31523       {
31524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31525       };
31526     } catch (std::exception& e) {
31527       {
31528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31529       };
31530     } catch (Dali::DaliException e) {
31531       {
31532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31533       };
31534     } catch (...) {
31535       {
31536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31537       };
31538     }
31539   }
31540
31541   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31542   return jresult;
31543 }
31544
31545
31546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31547   void * jresult ;
31548   unsigned int arg1 ;
31549   unsigned int arg2 ;
31550   Dali::LongPressGestureDetector result;
31551
31552   arg1 = (unsigned int)jarg1;
31553   arg2 = (unsigned int)jarg2;
31554   {
31555     try {
31556       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31557     } catch (std::out_of_range& e) {
31558       {
31559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (std::exception& e) {
31562       {
31563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (Dali::DaliException e) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31568       };
31569     } catch (...) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31572       };
31573     }
31574   }
31575
31576   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31577   return jresult;
31578 }
31579
31580
31581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31582   void * jresult ;
31583   Dali::BaseHandle arg1 ;
31584   Dali::BaseHandle *argp1 ;
31585   Dali::LongPressGestureDetector result;
31586
31587   argp1 = (Dali::BaseHandle *)jarg1;
31588   if (!argp1) {
31589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31590     return 0;
31591   }
31592   arg1 = *argp1;
31593   {
31594     try {
31595       result = Dali::LongPressGestureDetector::DownCast(arg1);
31596     } catch (std::out_of_range& e) {
31597       {
31598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31599       };
31600     } catch (std::exception& e) {
31601       {
31602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (Dali::DaliException e) {
31605       {
31606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31607       };
31608     } catch (...) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31611       };
31612     }
31613   }
31614
31615   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31616   return jresult;
31617 }
31618
31619
31620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31621   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31622
31623   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31624   {
31625     try {
31626       delete arg1;
31627     } catch (std::out_of_range& e) {
31628       {
31629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31630       };
31631     } catch (std::exception& e) {
31632       {
31633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31634       };
31635     } catch (Dali::DaliException e) {
31636       {
31637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31638       };
31639     } catch (...) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31642       };
31643     }
31644   }
31645
31646 }
31647
31648
31649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31650   void * jresult ;
31651   Dali::LongPressGestureDetector *arg1 = 0 ;
31652   Dali::LongPressGestureDetector *result = 0 ;
31653
31654   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31655   if (!arg1) {
31656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31657     return 0;
31658   }
31659   {
31660     try {
31661       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31662     } catch (std::out_of_range& e) {
31663       {
31664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31665       };
31666     } catch (std::exception& e) {
31667       {
31668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (Dali::DaliException e) {
31671       {
31672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31673       };
31674     } catch (...) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31677       };
31678     }
31679   }
31680
31681   jresult = (void *)result;
31682   return jresult;
31683 }
31684
31685
31686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31687   void * jresult ;
31688   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31689   Dali::LongPressGestureDetector *arg2 = 0 ;
31690   Dali::LongPressGestureDetector *result = 0 ;
31691
31692   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31693   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31694   if (!arg2) {
31695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31696     return 0;
31697   }
31698   {
31699     try {
31700       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31701     } catch (std::out_of_range& e) {
31702       {
31703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31704       };
31705     } catch (std::exception& e) {
31706       {
31707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (Dali::DaliException e) {
31710       {
31711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31712       };
31713     } catch (...) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31716       };
31717     }
31718   }
31719
31720   jresult = (void *)result;
31721   return jresult;
31722 }
31723
31724
31725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31726   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31727   unsigned int arg2 ;
31728
31729   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31730   arg2 = (unsigned int)jarg2;
31731   {
31732     try {
31733       (arg1)->SetTouchesRequired(arg2);
31734     } catch (std::out_of_range& e) {
31735       {
31736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31737       };
31738     } catch (std::exception& e) {
31739       {
31740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (Dali::DaliException e) {
31743       {
31744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31745       };
31746     } catch (...) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31749       };
31750     }
31751   }
31752
31753 }
31754
31755
31756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31757   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31758   unsigned int arg2 ;
31759   unsigned int arg3 ;
31760
31761   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31762   arg2 = (unsigned int)jarg2;
31763   arg3 = (unsigned int)jarg3;
31764   {
31765     try {
31766       (arg1)->SetTouchesRequired(arg2,arg3);
31767     } catch (std::out_of_range& e) {
31768       {
31769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31770       };
31771     } catch (std::exception& e) {
31772       {
31773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (Dali::DaliException e) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31778       };
31779     } catch (...) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31782       };
31783     }
31784   }
31785
31786 }
31787
31788
31789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31790   unsigned int jresult ;
31791   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31792   unsigned int result;
31793
31794   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31795   {
31796     try {
31797       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31798     } catch (std::out_of_range& e) {
31799       {
31800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31801       };
31802     } catch (std::exception& e) {
31803       {
31804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31805       };
31806     } catch (Dali::DaliException e) {
31807       {
31808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31809       };
31810     } catch (...) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31813       };
31814     }
31815   }
31816
31817   jresult = result;
31818   return jresult;
31819 }
31820
31821
31822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31823   unsigned int jresult ;
31824   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31825   unsigned int result;
31826
31827   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31828   {
31829     try {
31830       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31831     } catch (std::out_of_range& e) {
31832       {
31833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31834       };
31835     } catch (std::exception& e) {
31836       {
31837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31838       };
31839     } catch (Dali::DaliException e) {
31840       {
31841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31842       };
31843     } catch (...) {
31844       {
31845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31846       };
31847     }
31848   }
31849
31850   jresult = result;
31851   return jresult;
31852 }
31853
31854
31855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31856   void * jresult ;
31857   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31858   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31859
31860   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31861   {
31862     try {
31863       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31864     } catch (std::out_of_range& e) {
31865       {
31866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (std::exception& e) {
31869       {
31870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (Dali::DaliException e) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31875       };
31876     } catch (...) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31879       };
31880     }
31881   }
31882
31883   jresult = (void *)result;
31884   return jresult;
31885 }
31886
31887
31888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31889   void * jresult ;
31890   Dali::Gesture::State arg1 ;
31891   Dali::LongPressGesture *result = 0 ;
31892
31893   arg1 = (Dali::Gesture::State)jarg1;
31894   {
31895     try {
31896       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31897     } catch (std::out_of_range& e) {
31898       {
31899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (std::exception& e) {
31902       {
31903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (Dali::DaliException e) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31908       };
31909     } catch (...) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31912       };
31913     }
31914   }
31915
31916   jresult = (void *)result;
31917   return jresult;
31918 }
31919
31920
31921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31922   void * jresult ;
31923   Dali::LongPressGesture *arg1 = 0 ;
31924   Dali::LongPressGesture *result = 0 ;
31925
31926   arg1 = (Dali::LongPressGesture *)jarg1;
31927   if (!arg1) {
31928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31929     return 0;
31930   }
31931   {
31932     try {
31933       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31934     } catch (std::out_of_range& e) {
31935       {
31936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31937       };
31938     } catch (std::exception& e) {
31939       {
31940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31941       };
31942     } catch (Dali::DaliException e) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31945       };
31946     } catch (...) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31949       };
31950     }
31951   }
31952
31953   jresult = (void *)result;
31954   return jresult;
31955 }
31956
31957
31958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31959   void * jresult ;
31960   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31961   Dali::LongPressGesture *arg2 = 0 ;
31962   Dali::LongPressGesture *result = 0 ;
31963
31964   arg1 = (Dali::LongPressGesture *)jarg1;
31965   arg2 = (Dali::LongPressGesture *)jarg2;
31966   if (!arg2) {
31967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31968     return 0;
31969   }
31970   {
31971     try {
31972       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31973     } catch (std::out_of_range& e) {
31974       {
31975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31976       };
31977     } catch (std::exception& e) {
31978       {
31979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (Dali::DaliException e) {
31982       {
31983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31984       };
31985     } catch (...) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31988       };
31989     }
31990   }
31991
31992   jresult = (void *)result;
31993   return jresult;
31994 }
31995
31996
31997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31998   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31999
32000   arg1 = (Dali::LongPressGesture *)jarg1;
32001   {
32002     try {
32003       delete arg1;
32004     } catch (std::out_of_range& e) {
32005       {
32006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32007       };
32008     } catch (std::exception& e) {
32009       {
32010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (Dali::DaliException e) {
32013       {
32014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32015       };
32016     } catch (...) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32019       };
32020     }
32021   }
32022
32023 }
32024
32025
32026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32027   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32028   unsigned int arg2 ;
32029
32030   arg1 = (Dali::LongPressGesture *)jarg1;
32031   arg2 = (unsigned int)jarg2;
32032   if (arg1) (arg1)->numberOfTouches = arg2;
32033 }
32034
32035
32036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32037   unsigned int jresult ;
32038   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32039   unsigned int result;
32040
32041   arg1 = (Dali::LongPressGesture *)jarg1;
32042   result = (unsigned int) ((arg1)->numberOfTouches);
32043   jresult = result;
32044   return jresult;
32045 }
32046
32047
32048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32049   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32050   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32051
32052   arg1 = (Dali::LongPressGesture *)jarg1;
32053   arg2 = (Dali::Vector2 *)jarg2;
32054   if (arg1) (arg1)->screenPoint = *arg2;
32055 }
32056
32057
32058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32059   void * jresult ;
32060   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32061   Dali::Vector2 *result = 0 ;
32062
32063   arg1 = (Dali::LongPressGesture *)jarg1;
32064   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32065   jresult = (void *)result;
32066   return jresult;
32067 }
32068
32069
32070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32071   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32072   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32073
32074   arg1 = (Dali::LongPressGesture *)jarg1;
32075   arg2 = (Dali::Vector2 *)jarg2;
32076   if (arg1) (arg1)->localPoint = *arg2;
32077 }
32078
32079
32080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32081   void * jresult ;
32082   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32083   Dali::Vector2 *result = 0 ;
32084
32085   arg1 = (Dali::LongPressGesture *)jarg1;
32086   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32087   jresult = (void *)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32093   void * jresult ;
32094   Dali::WheelEvent *result = 0 ;
32095
32096   {
32097     try {
32098       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32114       };
32115     }
32116   }
32117
32118   jresult = (void *)result;
32119   return jresult;
32120 }
32121
32122
32123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32124   void * jresult ;
32125   Dali::WheelEvent::Type arg1 ;
32126   int arg2 ;
32127   unsigned int arg3 ;
32128   Dali::Vector2 arg4 ;
32129   int arg5 ;
32130   unsigned int arg6 ;
32131   Dali::Vector2 *argp4 ;
32132   Dali::WheelEvent *result = 0 ;
32133
32134   arg1 = (Dali::WheelEvent::Type)jarg1;
32135   arg2 = (int)jarg2;
32136   arg3 = (unsigned int)jarg3;
32137   argp4 = (Dali::Vector2 *)jarg4;
32138   if (!argp4) {
32139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32140     return 0;
32141   }
32142   arg4 = *argp4;
32143   arg5 = (int)jarg5;
32144   arg6 = (unsigned int)jarg6;
32145   {
32146     try {
32147       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32148     } catch (std::out_of_range& e) {
32149       {
32150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32151       };
32152     } catch (std::exception& e) {
32153       {
32154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (Dali::DaliException e) {
32157       {
32158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32159       };
32160     } catch (...) {
32161       {
32162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32163       };
32164     }
32165   }
32166
32167   jresult = (void *)result;
32168   return jresult;
32169 }
32170
32171
32172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32173   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32174
32175   arg1 = (Dali::WheelEvent *)jarg1;
32176   {
32177     try {
32178       delete arg1;
32179     } catch (std::out_of_range& e) {
32180       {
32181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32182       };
32183     } catch (std::exception& e) {
32184       {
32185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (Dali::DaliException e) {
32188       {
32189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32190       };
32191     } catch (...) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32194       };
32195     }
32196   }
32197
32198 }
32199
32200
32201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32202   unsigned int jresult ;
32203   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32204   bool result;
32205
32206   arg1 = (Dali::WheelEvent *)jarg1;
32207   {
32208     try {
32209       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32210     } catch (std::out_of_range& e) {
32211       {
32212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32213       };
32214     } catch (std::exception& e) {
32215       {
32216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32217       };
32218     } catch (Dali::DaliException e) {
32219       {
32220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32221       };
32222     } catch (...) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32225       };
32226     }
32227   }
32228
32229   jresult = result;
32230   return jresult;
32231 }
32232
32233
32234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32235   unsigned int jresult ;
32236   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32237   bool result;
32238
32239   arg1 = (Dali::WheelEvent *)jarg1;
32240   {
32241     try {
32242       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (Dali::DaliException e) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261
32262   jresult = result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32268   unsigned int jresult ;
32269   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32270   bool result;
32271
32272   arg1 = (Dali::WheelEvent *)jarg1;
32273   {
32274     try {
32275       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32276     } catch (std::out_of_range& e) {
32277       {
32278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32279       };
32280     } catch (std::exception& e) {
32281       {
32282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (Dali::DaliException e) {
32285       {
32286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32291       };
32292     }
32293   }
32294
32295   jresult = result;
32296   return jresult;
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32301   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32302   Dali::WheelEvent::Type arg2 ;
32303
32304   arg1 = (Dali::WheelEvent *)jarg1;
32305   arg2 = (Dali::WheelEvent::Type)jarg2;
32306   if (arg1) (arg1)->type = arg2;
32307 }
32308
32309
32310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32311   int jresult ;
32312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32313   Dali::WheelEvent::Type result;
32314
32315   arg1 = (Dali::WheelEvent *)jarg1;
32316   result = (Dali::WheelEvent::Type) ((arg1)->type);
32317   jresult = (int)result;
32318   return jresult;
32319 }
32320
32321
32322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32323   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32324   int arg2 ;
32325
32326   arg1 = (Dali::WheelEvent *)jarg1;
32327   arg2 = (int)jarg2;
32328   if (arg1) (arg1)->direction = arg2;
32329 }
32330
32331
32332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32333   int jresult ;
32334   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32335   int result;
32336
32337   arg1 = (Dali::WheelEvent *)jarg1;
32338   result = (int) ((arg1)->direction);
32339   jresult = result;
32340   return jresult;
32341 }
32342
32343
32344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32345   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32346   unsigned int arg2 ;
32347
32348   arg1 = (Dali::WheelEvent *)jarg1;
32349   arg2 = (unsigned int)jarg2;
32350   if (arg1) (arg1)->modifiers = arg2;
32351 }
32352
32353
32354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32355   unsigned int jresult ;
32356   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32357   unsigned int result;
32358
32359   arg1 = (Dali::WheelEvent *)jarg1;
32360   result = (unsigned int) ((arg1)->modifiers);
32361   jresult = result;
32362   return jresult;
32363 }
32364
32365
32366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32367   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32368   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32369
32370   arg1 = (Dali::WheelEvent *)jarg1;
32371   arg2 = (Dali::Vector2 *)jarg2;
32372   if (arg1) (arg1)->point = *arg2;
32373 }
32374
32375
32376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32377   void * jresult ;
32378   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32379   Dali::Vector2 *result = 0 ;
32380
32381   arg1 = (Dali::WheelEvent *)jarg1;
32382   result = (Dali::Vector2 *)& ((arg1)->point);
32383   jresult = (void *)result;
32384   return jresult;
32385 }
32386
32387
32388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32389   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32390   int arg2 ;
32391
32392   arg1 = (Dali::WheelEvent *)jarg1;
32393   arg2 = (int)jarg2;
32394   if (arg1) (arg1)->z = arg2;
32395 }
32396
32397
32398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32399   int jresult ;
32400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32401   int result;
32402
32403   arg1 = (Dali::WheelEvent *)jarg1;
32404   result = (int) ((arg1)->z);
32405   jresult = result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32411   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32412   unsigned int arg2 ;
32413
32414   arg1 = (Dali::WheelEvent *)jarg1;
32415   arg2 = (unsigned int)jarg2;
32416   if (arg1) (arg1)->timeStamp = arg2;
32417 }
32418
32419
32420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32421   unsigned int jresult ;
32422   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32423   unsigned int result;
32424
32425   arg1 = (Dali::WheelEvent *)jarg1;
32426   result = (unsigned int) ((arg1)->timeStamp);
32427   jresult = result;
32428   return jresult;
32429 }
32430
32431 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32432   char * jresult ;
32433   Dali::KeyEvent *arg1 = 0 ;
32434   std::string result;
32435
32436   arg1 = (Dali::KeyEvent *)jarg1;
32437   if (!arg1) {
32438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32439     return 0;
32440   }
32441   {
32442     try {
32443       result = arg1->GetDeviceName();
32444     } catch (std::out_of_range& e) {
32445       {
32446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32447       };
32448     } catch (std::exception& e) {
32449       {
32450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32451       };
32452     } catch (Dali::DaliException e) {
32453       {
32454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32455       };
32456     } catch (...) {
32457       {
32458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32459       };
32460     }
32461   }
32462
32463   jresult = SWIG_csharp_string_callback((&result)->c_str());
32464   return jresult;
32465 }
32466
32467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32468   int jresult ;
32469   Dali::KeyEvent *arg1 = 0 ;
32470   Dali::Device::Class::Type result;
32471
32472   arg1 = (Dali::KeyEvent *)jarg1;
32473   if (!arg1) {
32474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32475     return 0;
32476   }
32477   {
32478     try {
32479       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32480     } catch (std::out_of_range& e) {
32481       {
32482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32483       };
32484     } catch (std::exception& e) {
32485       {
32486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (Dali::DaliException e) {
32489       {
32490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32491       };
32492     } catch (...) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32495       };
32496     }
32497   }
32498
32499   jresult = (int)result;
32500   return jresult;
32501 }
32502
32503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32504   int jresult ;
32505   Dali::KeyEvent *arg1 = 0 ;
32506   Dali::Device::Subclass::Type result;
32507
32508   arg1 = (Dali::KeyEvent *)jarg1;
32509   if (!arg1) {
32510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32511     return 0;
32512   }
32513   {
32514     try {
32515       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32516     } catch (std::out_of_range& e) {
32517       {
32518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32519       };
32520     } catch (std::exception& e) {
32521       {
32522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32523       };
32524     } catch (Dali::DaliException e) {
32525       {
32526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32527       };
32528     } catch (...) {
32529       {
32530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32531       };
32532     }
32533   }
32534
32535   jresult = (int)result;
32536   return jresult;
32537 }
32538
32539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32540   Dali::Actor arg1 ;
32541   Dali::Actor *argp1 ;
32542
32543   argp1 = (Dali::Actor *)jarg1;
32544   if (!argp1) {
32545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32546     return ;
32547   }
32548   arg1 = *argp1;
32549   {
32550     try {
32551       arg1.Raise();
32552     } catch (std::out_of_range& e) {
32553       {
32554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32555       };
32556     } catch (std::exception& e) {
32557       {
32558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32559       };
32560     } catch (Dali::DaliException e) {
32561       {
32562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32563       };
32564     } catch (...) {
32565       {
32566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32567       };
32568     }
32569   }
32570
32571 }
32572
32573
32574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32575   Dali::Actor arg1 ;
32576   Dali::Actor *argp1 ;
32577
32578   argp1 = (Dali::Actor *)jarg1;
32579   if (!argp1) {
32580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32581     return ;
32582   }
32583   arg1 = *argp1;
32584   {
32585     try {
32586       arg1.Lower();
32587     } catch (std::out_of_range& e) {
32588       {
32589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32590       };
32591     } catch (std::exception& e) {
32592       {
32593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32594       };
32595     } catch (Dali::DaliException e) {
32596       {
32597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32598       };
32599     } catch (...) {
32600       {
32601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32602       };
32603     }
32604   }
32605
32606 }
32607
32608
32609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32610   Dali::Actor arg1 ;
32611   Dali::Actor *argp1 ;
32612
32613   argp1 = (Dali::Actor *)jarg1;
32614   if (!argp1) {
32615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32616     return ;
32617   }
32618   arg1 = *argp1;
32619   {
32620     try {
32621       arg1.RaiseToTop();
32622     } catch (std::out_of_range& e) {
32623       {
32624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32625       };
32626     } catch (std::exception& e) {
32627       {
32628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (Dali::DaliException e) {
32631       {
32632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32633       };
32634     } catch (...) {
32635       {
32636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32637       };
32638     }
32639   }
32640
32641 }
32642
32643
32644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32645   Dali::Actor arg1 ;
32646   Dali::Actor *argp1 ;
32647
32648   argp1 = (Dali::Actor *)jarg1;
32649   if (!argp1) {
32650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32651     return ;
32652   }
32653   arg1 = *argp1;
32654   {
32655     try {
32656       arg1.LowerToBottom();
32657     } catch (std::out_of_range& e) {
32658       {
32659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32660       };
32661     } catch (std::exception& e) {
32662       {
32663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (Dali::DaliException e) {
32666       {
32667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32668       };
32669     } catch (...) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32672       };
32673     }
32674   }
32675
32676 }
32677
32678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32679   Dali::Actor arg1 ;
32680   Dali::Actor arg2 ;
32681   Dali::Actor *argp1 ;
32682   Dali::Actor *argp2 ;
32683
32684   argp1 = (Dali::Actor *)jarg1;
32685   if (!argp1) {
32686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32687     return ;
32688   }
32689   arg1 = *argp1;
32690   argp2 = (Dali::Actor *)jarg2;
32691   if (!argp2) {
32692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32693     return ;
32694   }
32695   arg2 = *argp2;
32696   {
32697     try {
32698       arg1.RaiseAbove(arg2);
32699     } catch (std::out_of_range& e) {
32700       {
32701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32702       };
32703     } catch (std::exception& e) {
32704       {
32705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (Dali::DaliException e) {
32708       {
32709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32710       };
32711     } catch (...) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32714       };
32715     }
32716   }
32717
32718 }
32719
32720
32721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32722   Dali::Actor arg1 ;
32723   Dali::Actor arg2 ;
32724   Dali::Actor *argp1 ;
32725   Dali::Actor *argp2 ;
32726
32727   argp1 = (Dali::Actor *)jarg1;
32728   if (!argp1) {
32729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32730     return ;
32731   }
32732   arg1 = *argp1;
32733   argp2 = (Dali::Actor *)jarg2;
32734   if (!argp2) {
32735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32736     return ;
32737   }
32738   arg2 = *argp2;
32739   {
32740     try {
32741       arg1.LowerBelow(arg2);
32742     } catch (std::out_of_range& e) {
32743       {
32744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32745       };
32746     } catch (std::exception& e) {
32747       {
32748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (Dali::DaliException e) {
32751       {
32752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32753       };
32754     } catch (...) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32757       };
32758     }
32759   }
32760
32761 }
32762
32763
32764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32765   void * jresult ;
32766   Dali::Actor arg1 ;
32767   Dali::Actor *argp1 ;
32768   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32769
32770   argp1 = (Dali::Actor *)jarg1;
32771   if (!argp1) {
32772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32773     return 0;
32774   }
32775   arg1 = *argp1;
32776   {
32777     try {
32778       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32779     } catch (std::out_of_range& e) {
32780       {
32781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32782       };
32783     } catch (std::exception& e) {
32784       {
32785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32786       };
32787     } catch (Dali::DaliException e) {
32788       {
32789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32790       };
32791     } catch (...) {
32792       {
32793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32794       };
32795     }
32796   }
32797
32798   jresult = (void *)result;
32799   return jresult;
32800 }
32801
32802
32803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32804   void * jresult ;
32805   Dali::Actor *arg1 ;
32806   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32807
32808   arg1 = (Dali::Actor *)jarg1;
32809   {
32810     try {
32811       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32812     } catch (std::out_of_range& e) {
32813       {
32814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32815       };
32816     } catch (std::exception& e) {
32817       {
32818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32819       };
32820     } catch (Dali::DaliException e) {
32821       {
32822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32823       };
32824     } catch (...) {
32825       {
32826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32827       };
32828     }
32829   }
32830
32831   jresult = (void *)result;
32832   return jresult;
32833 }
32834
32835
32836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32837   int jresult ;
32838   int result;
32839
32840   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32841   jresult = (int)result;
32842   return jresult;
32843 }
32844
32845
32846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32847   int jresult ;
32848   int result;
32849
32850   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32851   jresult = (int)result;
32852   return jresult;
32853 }
32854
32855
32856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32857   int jresult ;
32858   int result;
32859
32860   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32861   jresult = (int)result;
32862   return jresult;
32863 }
32864
32865
32866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32867   int jresult ;
32868   int result;
32869
32870   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32871   jresult = (int)result;
32872   return jresult;
32873 }
32874
32875
32876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32877   int jresult ;
32878   int result;
32879
32880   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32881   jresult = (int)result;
32882   return jresult;
32883 }
32884
32885
32886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32887   int jresult ;
32888   int result;
32889
32890   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32891   jresult = (int)result;
32892   return jresult;
32893 }
32894
32895
32896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32897   int jresult ;
32898   int result;
32899
32900   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32901   jresult = (int)result;
32902   return jresult;
32903 }
32904
32905
32906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32907   int jresult ;
32908   int result;
32909
32910   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32911   jresult = (int)result;
32912   return jresult;
32913 }
32914
32915
32916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32917   int jresult ;
32918   int result;
32919
32920   result = (int)Dali::Actor::Property::SIZE;
32921   jresult = (int)result;
32922   return jresult;
32923 }
32924
32925
32926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32927   int jresult ;
32928   int result;
32929
32930   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32931   jresult = (int)result;
32932   return jresult;
32933 }
32934
32935
32936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32937   int jresult ;
32938   int result;
32939
32940   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32941   jresult = (int)result;
32942   return jresult;
32943 }
32944
32945
32946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32947   int jresult ;
32948   int result;
32949
32950   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32951   jresult = (int)result;
32952   return jresult;
32953 }
32954
32955
32956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32957   int jresult ;
32958   int result;
32959
32960   result = (int)Dali::Actor::Property::POSITION;
32961   jresult = (int)result;
32962   return jresult;
32963 }
32964
32965
32966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32967   int jresult ;
32968   int result;
32969
32970   result = (int)Dali::Actor::Property::POSITION_X;
32971   jresult = (int)result;
32972   return jresult;
32973 }
32974
32975
32976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32977   int jresult ;
32978   int result;
32979
32980   result = (int)Dali::Actor::Property::POSITION_Y;
32981   jresult = (int)result;
32982   return jresult;
32983 }
32984
32985
32986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32987   int jresult ;
32988   int result;
32989
32990   result = (int)Dali::Actor::Property::POSITION_Z;
32991   jresult = (int)result;
32992   return jresult;
32993 }
32994
32995
32996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32997   int jresult ;
32998   int result;
32999
33000   result = (int)Dali::Actor::Property::WORLD_POSITION;
33001   jresult = (int)result;
33002   return jresult;
33003 }
33004
33005
33006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33007   int jresult ;
33008   int result;
33009
33010   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33011   jresult = (int)result;
33012   return jresult;
33013 }
33014
33015
33016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33017   int jresult ;
33018   int result;
33019
33020   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33021   jresult = (int)result;
33022   return jresult;
33023 }
33024
33025
33026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33027   int jresult ;
33028   int result;
33029
33030   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33031   jresult = (int)result;
33032   return jresult;
33033 }
33034
33035
33036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33037   int jresult ;
33038   int result;
33039
33040   result = (int)Dali::Actor::Property::ORIENTATION;
33041   jresult = (int)result;
33042   return jresult;
33043 }
33044
33045
33046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33047   int jresult ;
33048   int result;
33049
33050   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33051   jresult = (int)result;
33052   return jresult;
33053 }
33054
33055
33056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33057   int jresult ;
33058   int result;
33059
33060   result = (int)Dali::Actor::Property::SCALE;
33061   jresult = (int)result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33067   int jresult ;
33068   int result;
33069
33070   result = (int)Dali::Actor::Property::SCALE_X;
33071   jresult = (int)result;
33072   return jresult;
33073 }
33074
33075
33076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33077   int jresult ;
33078   int result;
33079
33080   result = (int)Dali::Actor::Property::SCALE_Y;
33081   jresult = (int)result;
33082   return jresult;
33083 }
33084
33085
33086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33087   int jresult ;
33088   int result;
33089
33090   result = (int)Dali::Actor::Property::SCALE_Z;
33091   jresult = (int)result;
33092   return jresult;
33093 }
33094
33095
33096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33097   int jresult ;
33098   int result;
33099
33100   result = (int)Dali::Actor::Property::WORLD_SCALE;
33101   jresult = (int)result;
33102   return jresult;
33103 }
33104
33105
33106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33107   int jresult ;
33108   int result;
33109
33110   result = (int)Dali::Actor::Property::VISIBLE;
33111   jresult = (int)result;
33112   return jresult;
33113 }
33114
33115
33116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33117   int jresult ;
33118   int result;
33119
33120   result = (int)Dali::Actor::Property::COLOR;
33121   jresult = (int)result;
33122   return jresult;
33123 }
33124
33125
33126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33127   int jresult ;
33128   int result;
33129
33130   result = (int)Dali::Actor::Property::COLOR_RED;
33131   jresult = (int)result;
33132   return jresult;
33133 }
33134
33135
33136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33137   int jresult ;
33138   int result;
33139
33140   result = (int)Dali::Actor::Property::COLOR_GREEN;
33141   jresult = (int)result;
33142   return jresult;
33143 }
33144
33145
33146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33147   int jresult ;
33148   int result;
33149
33150   result = (int)Dali::Actor::Property::COLOR_BLUE;
33151   jresult = (int)result;
33152   return jresult;
33153 }
33154
33155
33156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33157   int jresult ;
33158   int result;
33159
33160   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33161   jresult = (int)result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33167   int jresult ;
33168   int result;
33169
33170   result = (int)Dali::Actor::Property::WORLD_COLOR;
33171   jresult = (int)result;
33172   return jresult;
33173 }
33174
33175
33176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33177   int jresult ;
33178   int result;
33179
33180   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33181   jresult = (int)result;
33182   return jresult;
33183 }
33184
33185
33186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33187   int jresult ;
33188   int result;
33189
33190   result = (int)Dali::Actor::Property::NAME;
33191   jresult = (int)result;
33192   return jresult;
33193 }
33194
33195
33196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33197   int jresult ;
33198   int result;
33199
33200   result = (int)Dali::Actor::Property::SENSITIVE;
33201   jresult = (int)result;
33202   return jresult;
33203 }
33204
33205
33206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33207   int jresult ;
33208   int result;
33209
33210   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33211   jresult = (int)result;
33212   return jresult;
33213 }
33214
33215
33216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33217   int jresult ;
33218   int result;
33219
33220   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33221   jresult = (int)result;
33222   return jresult;
33223 }
33224
33225
33226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33227   int jresult ;
33228   int result;
33229
33230   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33231   jresult = (int)result;
33232   return jresult;
33233 }
33234
33235
33236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33237   int jresult ;
33238   int result;
33239
33240   result = (int)Dali::Actor::Property::COLOR_MODE;
33241   jresult = (int)result;
33242   return jresult;
33243 }
33244
33245
33246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33247   int jresult ;
33248   int result;
33249
33250   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33251   jresult = (int)result;
33252   return jresult;
33253 }
33254
33255
33256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33257   int jresult ;
33258   int result;
33259
33260   result = (int)Dali::Actor::Property::DRAW_MODE;
33261   jresult = (int)result;
33262   return jresult;
33263 }
33264
33265
33266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33267   int jresult ;
33268   int result;
33269
33270   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33271   jresult = (int)result;
33272   return jresult;
33273 }
33274
33275
33276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33277   int jresult ;
33278   int result;
33279
33280   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33281   jresult = (int)result;
33282   return jresult;
33283 }
33284
33285
33286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33287   int jresult ;
33288   int result;
33289
33290   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33291   jresult = (int)result;
33292   return jresult;
33293 }
33294
33295
33296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33297   int jresult ;
33298   int result;
33299
33300   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33301   jresult = (int)result;
33302   return jresult;
33303 }
33304
33305
33306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33307   int jresult ;
33308   int result;
33309
33310   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33311   jresult = (int)result;
33312   return jresult;
33313 }
33314
33315
33316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33317   int jresult ;
33318   int result;
33319
33320   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33321   jresult = (int)result;
33322   return jresult;
33323 }
33324
33325
33326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33327   int jresult ;
33328   int result;
33329
33330   result = (int)Dali::Actor::Property::PADDING;
33331   jresult = (int)result;
33332   return jresult;
33333 }
33334
33335
33336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33337   int jresult ;
33338   int result;
33339
33340   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33341   jresult = (int)result;
33342   return jresult;
33343 }
33344
33345
33346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33347   int jresult ;
33348   int result;
33349
33350   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33351   jresult = (int)result;
33352   return jresult;
33353 }
33354
33355
33356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33357   int jresult ;
33358   int result;
33359
33360   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33361   jresult = (int)result;
33362   return jresult;
33363 }
33364
33365
33366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33367   int jresult ;
33368   int result;
33369
33370   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33371   jresult = (int)result;
33372   return jresult;
33373 }
33374
33375
33376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33377   void * jresult ;
33378   Dali::Actor::Property *result = 0 ;
33379
33380   {
33381     try {
33382       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33383     } catch (std::out_of_range& e) {
33384       {
33385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33386       };
33387     } catch (std::exception& e) {
33388       {
33389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33390       };
33391     } catch (Dali::DaliException e) {
33392       {
33393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33394       };
33395     } catch (...) {
33396       {
33397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33398       };
33399     }
33400   }
33401
33402   jresult = (void *)result;
33403   return jresult;
33404 }
33405
33406
33407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33408   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33409
33410   arg1 = (Dali::Actor::Property *)jarg1;
33411   {
33412     try {
33413       delete arg1;
33414     } catch (std::out_of_range& e) {
33415       {
33416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33417       };
33418     } catch (std::exception& e) {
33419       {
33420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33421       };
33422     } catch (Dali::DaliException e) {
33423       {
33424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33425       };
33426     } catch (...) {
33427       {
33428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33429       };
33430     }
33431   }
33432
33433 }
33434
33435
33436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33437   void * jresult ;
33438   Dali::Actor *result = 0 ;
33439
33440   {
33441     try {
33442       result = (Dali::Actor *)new Dali::Actor();
33443     } catch (std::out_of_range& e) {
33444       {
33445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33446       };
33447     } catch (std::exception& e) {
33448       {
33449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33450       };
33451     } catch (Dali::DaliException e) {
33452       {
33453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33454       };
33455     } catch (...) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33458       };
33459     }
33460   }
33461
33462   jresult = (void *)result;
33463   return jresult;
33464 }
33465
33466
33467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33468   void * jresult ;
33469   Dali::Actor result;
33470
33471   {
33472     try {
33473       result = Dali::Actor::New();
33474     } catch (std::out_of_range& e) {
33475       {
33476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33477       };
33478     } catch (std::exception& e) {
33479       {
33480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33481       };
33482     } catch (Dali::DaliException e) {
33483       {
33484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33485       };
33486     } catch (...) {
33487       {
33488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33489       };
33490     }
33491   }
33492
33493   jresult = new Dali::Actor((const Dali::Actor &)result);
33494   return jresult;
33495 }
33496
33497
33498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33499   void * jresult ;
33500   Dali::BaseHandle arg1 ;
33501   Dali::BaseHandle *argp1 ;
33502   Dali::Actor result;
33503
33504   argp1 = (Dali::BaseHandle *)jarg1;
33505   if (!argp1) {
33506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33507     return 0;
33508   }
33509   arg1 = *argp1;
33510   {
33511     try {
33512       result = Dali::Actor::DownCast(arg1);
33513     } catch (std::out_of_range& e) {
33514       {
33515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33516       };
33517     } catch (std::exception& e) {
33518       {
33519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33520       };
33521     } catch (Dali::DaliException e) {
33522       {
33523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33524       };
33525     } catch (...) {
33526       {
33527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33528       };
33529     }
33530   }
33531
33532   jresult = new Dali::Actor((const Dali::Actor &)result);
33533   return jresult;
33534 }
33535
33536
33537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33539
33540   arg1 = (Dali::Actor *)jarg1;
33541   {
33542     try {
33543       delete arg1;
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33551       };
33552     } catch (Dali::DaliException e) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33555       };
33556     } catch (...) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33559       };
33560     }
33561   }
33562
33563 }
33564
33565
33566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33567   void * jresult ;
33568   Dali::Actor *arg1 = 0 ;
33569   Dali::Actor *result = 0 ;
33570
33571   arg1 = (Dali::Actor *)jarg1;
33572   if (!arg1) {
33573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33574     return 0;
33575   }
33576   {
33577     try {
33578       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33579     } catch (std::out_of_range& e) {
33580       {
33581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (std::exception& e) {
33584       {
33585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33586       };
33587     } catch (Dali::DaliException e) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33590       };
33591     } catch (...) {
33592       {
33593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33594       };
33595     }
33596   }
33597
33598   jresult = (void *)result;
33599   return jresult;
33600 }
33601
33602
33603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33604   void * jresult ;
33605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33606   Dali::Actor *arg2 = 0 ;
33607   Dali::Actor *result = 0 ;
33608
33609   arg1 = (Dali::Actor *)jarg1;
33610   arg2 = (Dali::Actor *)jarg2;
33611   if (!arg2) {
33612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33613     return 0;
33614   }
33615   {
33616     try {
33617       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33618     } catch (std::out_of_range& e) {
33619       {
33620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33621       };
33622     } catch (std::exception& e) {
33623       {
33624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33625       };
33626     } catch (Dali::DaliException e) {
33627       {
33628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33629       };
33630     } catch (...) {
33631       {
33632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33633       };
33634     }
33635   }
33636
33637   jresult = (void *)result;
33638   return jresult;
33639 }
33640
33641
33642 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33643   char * jresult ;
33644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33645   std::string *result = 0 ;
33646
33647   arg1 = (Dali::Actor *)jarg1;
33648   {
33649     try {
33650       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33651     } catch (std::out_of_range& e) {
33652       {
33653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33654       };
33655     } catch (std::exception& e) {
33656       {
33657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33658       };
33659     } catch (Dali::DaliException e) {
33660       {
33661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33662       };
33663     } catch (...) {
33664       {
33665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33666       };
33667     }
33668   }
33669
33670   jresult = SWIG_csharp_string_callback(result->c_str());
33671   return jresult;
33672 }
33673
33674
33675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33677   std::string *arg2 = 0 ;
33678
33679   arg1 = (Dali::Actor *)jarg1;
33680   if (!jarg2) {
33681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33682     return ;
33683   }
33684   std::string arg2_str(jarg2);
33685   arg2 = &arg2_str;
33686   {
33687     try {
33688       (arg1)->SetName((std::string const &)*arg2);
33689     } catch (std::out_of_range& e) {
33690       {
33691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33692       };
33693     } catch (std::exception& e) {
33694       {
33695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33696       };
33697     } catch (Dali::DaliException e) {
33698       {
33699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33700       };
33701     } catch (...) {
33702       {
33703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33704       };
33705     }
33706   }
33707
33708
33709   //argout typemap for const std::string&
33710
33711 }
33712
33713
33714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33715   unsigned int jresult ;
33716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33717   unsigned int result;
33718
33719   arg1 = (Dali::Actor *)jarg1;
33720   {
33721     try {
33722       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33723     } catch (std::out_of_range& e) {
33724       {
33725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33726       };
33727     } catch (std::exception& e) {
33728       {
33729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33730       };
33731     } catch (Dali::DaliException e) {
33732       {
33733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33734       };
33735     } catch (...) {
33736       {
33737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33738       };
33739     }
33740   }
33741
33742   jresult = result;
33743   return jresult;
33744 }
33745
33746
33747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33748   unsigned int jresult ;
33749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33750   bool result;
33751
33752   arg1 = (Dali::Actor *)jarg1;
33753   {
33754     try {
33755       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33756     } catch (std::out_of_range& e) {
33757       {
33758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (std::exception& e) {
33761       {
33762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33763       };
33764     } catch (Dali::DaliException e) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33767       };
33768     } catch (...) {
33769       {
33770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33771       };
33772     }
33773   }
33774
33775   jresult = result;
33776   return jresult;
33777 }
33778
33779
33780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33781   unsigned int jresult ;
33782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33783   bool result;
33784
33785   arg1 = (Dali::Actor *)jarg1;
33786   {
33787     try {
33788       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (Dali::DaliException e) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33800       };
33801     } catch (...) {
33802       {
33803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33804       };
33805     }
33806   }
33807
33808   jresult = result;
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33814   unsigned int jresult ;
33815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33816   bool result;
33817
33818   arg1 = (Dali::Actor *)jarg1;
33819   {
33820     try {
33821       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33822     } catch (std::out_of_range& e) {
33823       {
33824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (std::exception& e) {
33827       {
33828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (Dali::DaliException e) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33833       };
33834     } catch (...) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33837       };
33838     }
33839   }
33840
33841   jresult = result;
33842   return jresult;
33843 }
33844
33845
33846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33847   void * jresult ;
33848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33849   Dali::Layer result;
33850
33851   arg1 = (Dali::Actor *)jarg1;
33852   {
33853     try {
33854       result = (arg1)->GetLayer();
33855     } catch (std::out_of_range& e) {
33856       {
33857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (std::exception& e) {
33860       {
33861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (Dali::DaliException e) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33866       };
33867     } catch (...) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33870       };
33871     }
33872   }
33873
33874   jresult = new Dali::Layer((const Dali::Layer &)result);
33875   return jresult;
33876 }
33877
33878
33879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33880   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33881   Dali::Actor arg2 ;
33882   Dali::Actor *argp2 ;
33883
33884   arg1 = (Dali::Actor *)jarg1;
33885   argp2 = (Dali::Actor *)jarg2;
33886   if (!argp2) {
33887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33888     return ;
33889   }
33890   arg2 = *argp2;
33891   {
33892     try {
33893       (arg1)->Add(arg2);
33894     } catch (std::out_of_range& e) {
33895       {
33896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33897       };
33898     } catch (std::exception& e) {
33899       {
33900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33901       };
33902     } catch (Dali::DaliException e) {
33903       {
33904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33905       };
33906     } catch (...) {
33907       {
33908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33909       };
33910     }
33911   }
33912
33913 }
33914
33915
33916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33918   Dali::Actor arg2 ;
33919   Dali::Actor *argp2 ;
33920
33921   arg1 = (Dali::Actor *)jarg1;
33922   argp2 = (Dali::Actor *)jarg2;
33923   if (!argp2) {
33924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33925     return ;
33926   }
33927   arg2 = *argp2;
33928   {
33929     try {
33930       (arg1)->Remove(arg2);
33931     } catch (std::out_of_range& e) {
33932       {
33933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33934       };
33935     } catch (std::exception& e) {
33936       {
33937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33938       };
33939     } catch (Dali::DaliException e) {
33940       {
33941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33942       };
33943     } catch (...) {
33944       {
33945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33946       };
33947     }
33948   }
33949
33950 }
33951
33952
33953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33955
33956   arg1 = (Dali::Actor *)jarg1;
33957   {
33958     try {
33959       (arg1)->Unparent();
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (Dali::DaliException e) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33971       };
33972     } catch (...) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33975       };
33976     }
33977   }
33978
33979 }
33980
33981
33982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33983   unsigned int jresult ;
33984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33985   unsigned int result;
33986
33987   arg1 = (Dali::Actor *)jarg1;
33988   {
33989     try {
33990       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33991     } catch (std::out_of_range& e) {
33992       {
33993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (std::exception& e) {
33996       {
33997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33998       };
33999     } catch (Dali::DaliException e) {
34000       {
34001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34002       };
34003     } catch (...) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34006       };
34007     }
34008   }
34009
34010   jresult = result;
34011   return jresult;
34012 }
34013
34014
34015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34016   void * jresult ;
34017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34018   unsigned int arg2 ;
34019   Dali::Actor result;
34020
34021   arg1 = (Dali::Actor *)jarg1;
34022   arg2 = (unsigned int)jarg2;
34023   {
34024     try {
34025       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (Dali::DaliException e) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34037       };
34038     } catch (...) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34041       };
34042     }
34043   }
34044
34045   jresult = new Dali::Actor((const Dali::Actor &)result);
34046   return jresult;
34047 }
34048
34049
34050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34051   void * jresult ;
34052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34053   std::string *arg2 = 0 ;
34054   Dali::Actor result;
34055
34056   arg1 = (Dali::Actor *)jarg1;
34057   if (!jarg2) {
34058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34059     return 0;
34060   }
34061   std::string arg2_str(jarg2);
34062   arg2 = &arg2_str;
34063   {
34064     try {
34065       result = (arg1)->FindChildByName((std::string const &)*arg2);
34066     } catch (std::out_of_range& e) {
34067       {
34068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34069       };
34070     } catch (std::exception& e) {
34071       {
34072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34073       };
34074     } catch (Dali::DaliException e) {
34075       {
34076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34077       };
34078     } catch (...) {
34079       {
34080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34081       };
34082     }
34083   }
34084
34085   jresult = new Dali::Actor((const Dali::Actor &)result);
34086
34087   //argout typemap for const std::string&
34088
34089   return jresult;
34090 }
34091
34092
34093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34094   void * jresult ;
34095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34096   unsigned int arg2 ;
34097   Dali::Actor result;
34098
34099   arg1 = (Dali::Actor *)jarg1;
34100   arg2 = (unsigned int)jarg2;
34101   {
34102     try {
34103       result = (arg1)->FindChildById(arg2);
34104     } catch (std::out_of_range& e) {
34105       {
34106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34107       };
34108     } catch (std::exception& e) {
34109       {
34110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34111       };
34112     } catch (Dali::DaliException e) {
34113       {
34114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34115       };
34116     } catch (...) {
34117       {
34118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34119       };
34120     }
34121   }
34122
34123   jresult = new Dali::Actor((const Dali::Actor &)result);
34124   return jresult;
34125 }
34126
34127
34128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34129   void * jresult ;
34130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34131   Dali::Actor result;
34132
34133   arg1 = (Dali::Actor *)jarg1;
34134   {
34135     try {
34136       result = ((Dali::Actor const *)arg1)->GetParent();
34137     } catch (std::out_of_range& e) {
34138       {
34139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34140       };
34141     } catch (std::exception& e) {
34142       {
34143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34144       };
34145     } catch (Dali::DaliException e) {
34146       {
34147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34148       };
34149     } catch (...) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34152       };
34153     }
34154   }
34155
34156   jresult = new Dali::Actor((const Dali::Actor &)result);
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34163   Dali::Vector3 *arg2 = 0 ;
34164
34165   arg1 = (Dali::Actor *)jarg1;
34166   arg2 = (Dali::Vector3 *)jarg2;
34167   if (!arg2) {
34168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34169     return ;
34170   }
34171   {
34172     try {
34173       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34174     } catch (std::out_of_range& e) {
34175       {
34176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34177       };
34178     } catch (std::exception& e) {
34179       {
34180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34181       };
34182     } catch (Dali::DaliException e) {
34183       {
34184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34185       };
34186     } catch (...) {
34187       {
34188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34189       };
34190     }
34191   }
34192
34193 }
34194
34195
34196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34197   void * jresult ;
34198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34199   Dali::Vector3 result;
34200
34201   arg1 = (Dali::Actor *)jarg1;
34202   {
34203     try {
34204       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34205     } catch (std::out_of_range& e) {
34206       {
34207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34208       };
34209     } catch (std::exception& e) {
34210       {
34211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34212       };
34213     } catch (Dali::DaliException e) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34216       };
34217     } catch (...) {
34218       {
34219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34220       };
34221     }
34222   }
34223
34224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34225   return jresult;
34226 }
34227
34228
34229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34231   Dali::Vector3 *arg2 = 0 ;
34232
34233   arg1 = (Dali::Actor *)jarg1;
34234   arg2 = (Dali::Vector3 *)jarg2;
34235   if (!arg2) {
34236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34237     return ;
34238   }
34239   {
34240     try {
34241       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34242     } catch (std::out_of_range& e) {
34243       {
34244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34245       };
34246     } catch (std::exception& e) {
34247       {
34248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34249       };
34250     } catch (Dali::DaliException e) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34253       };
34254     } catch (...) {
34255       {
34256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34257       };
34258     }
34259   }
34260
34261 }
34262
34263
34264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34265   void * jresult ;
34266   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34267   Dali::Vector3 result;
34268
34269   arg1 = (Dali::Actor *)jarg1;
34270   {
34271     try {
34272       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34273     } catch (std::out_of_range& e) {
34274       {
34275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34276       };
34277     } catch (std::exception& e) {
34278       {
34279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34280       };
34281     } catch (Dali::DaliException e) {
34282       {
34283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34284       };
34285     } catch (...) {
34286       {
34287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34288       };
34289     }
34290   }
34291
34292   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34293   return jresult;
34294 }
34295
34296
34297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34299   float arg2 ;
34300   float arg3 ;
34301
34302   arg1 = (Dali::Actor *)jarg1;
34303   arg2 = (float)jarg2;
34304   arg3 = (float)jarg3;
34305   {
34306     try {
34307       (arg1)->SetSize(arg2,arg3);
34308     } catch (std::out_of_range& e) {
34309       {
34310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34311       };
34312     } catch (std::exception& e) {
34313       {
34314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34315       };
34316     } catch (Dali::DaliException e) {
34317       {
34318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34319       };
34320     } catch (...) {
34321       {
34322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34323       };
34324     }
34325   }
34326
34327 }
34328
34329
34330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34331   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34332   float arg2 ;
34333   float arg3 ;
34334   float arg4 ;
34335
34336   arg1 = (Dali::Actor *)jarg1;
34337   arg2 = (float)jarg2;
34338   arg3 = (float)jarg3;
34339   arg4 = (float)jarg4;
34340   {
34341     try {
34342       (arg1)->SetSize(arg2,arg3,arg4);
34343     } catch (std::out_of_range& e) {
34344       {
34345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34346       };
34347     } catch (std::exception& e) {
34348       {
34349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34350       };
34351     } catch (Dali::DaliException e) {
34352       {
34353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34354       };
34355     } catch (...) {
34356       {
34357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34358       };
34359     }
34360   }
34361
34362 }
34363
34364
34365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34367   Dali::Vector2 *arg2 = 0 ;
34368
34369   arg1 = (Dali::Actor *)jarg1;
34370   arg2 = (Dali::Vector2 *)jarg2;
34371   if (!arg2) {
34372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34373     return ;
34374   }
34375   {
34376     try {
34377       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34378     } catch (std::out_of_range& e) {
34379       {
34380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34381       };
34382     } catch (std::exception& e) {
34383       {
34384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34385       };
34386     } catch (Dali::DaliException e) {
34387       {
34388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34389       };
34390     } catch (...) {
34391       {
34392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34393       };
34394     }
34395   }
34396
34397 }
34398
34399
34400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34402   Dali::Vector3 *arg2 = 0 ;
34403
34404   arg1 = (Dali::Actor *)jarg1;
34405   arg2 = (Dali::Vector3 *)jarg2;
34406   if (!arg2) {
34407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34408     return ;
34409   }
34410   {
34411     try {
34412       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34413     } catch (std::out_of_range& e) {
34414       {
34415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34416       };
34417     } catch (std::exception& e) {
34418       {
34419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34420       };
34421     } catch (Dali::DaliException e) {
34422       {
34423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34424       };
34425     } catch (...) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34428       };
34429     }
34430   }
34431
34432 }
34433
34434
34435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34436   void * jresult ;
34437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34438   Dali::Vector3 result;
34439
34440   arg1 = (Dali::Actor *)jarg1;
34441   {
34442     try {
34443       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34444     } catch (std::out_of_range& e) {
34445       {
34446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34447       };
34448     } catch (std::exception& e) {
34449       {
34450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34451       };
34452     } catch (Dali::DaliException e) {
34453       {
34454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34455       };
34456     } catch (...) {
34457       {
34458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34459       };
34460     }
34461   }
34462
34463   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34464   return jresult;
34465 }
34466
34467
34468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34469   void * jresult ;
34470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34471   Dali::Vector3 result;
34472
34473   arg1 = (Dali::Actor *)jarg1;
34474   {
34475     try {
34476       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34477     } catch (std::out_of_range& e) {
34478       {
34479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34480       };
34481     } catch (std::exception& e) {
34482       {
34483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34484       };
34485     } catch (Dali::DaliException e) {
34486       {
34487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34488       };
34489     } catch (...) {
34490       {
34491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34492       };
34493     }
34494   }
34495
34496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34497   return jresult;
34498 }
34499
34500
34501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34502   void * jresult ;
34503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34504   Dali::Vector3 result;
34505
34506   arg1 = (Dali::Actor *)jarg1;
34507   {
34508     try {
34509       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34510     } catch (std::out_of_range& e) {
34511       {
34512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (std::exception& e) {
34515       {
34516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34517       };
34518     } catch (Dali::DaliException e) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34521       };
34522     } catch (...) {
34523       {
34524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34525       };
34526     }
34527   }
34528
34529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34530   return jresult;
34531 }
34532
34533
34534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34536   float arg2 ;
34537   float arg3 ;
34538
34539   arg1 = (Dali::Actor *)jarg1;
34540   arg2 = (float)jarg2;
34541   arg3 = (float)jarg3;
34542   {
34543     try {
34544       (arg1)->SetPosition(arg2,arg3);
34545     } catch (std::out_of_range& e) {
34546       {
34547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34548       };
34549     } catch (std::exception& e) {
34550       {
34551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34552       };
34553     } catch (Dali::DaliException e) {
34554       {
34555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34556       };
34557     } catch (...) {
34558       {
34559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34560       };
34561     }
34562   }
34563
34564 }
34565
34566
34567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34569   float arg2 ;
34570   float arg3 ;
34571   float arg4 ;
34572
34573   arg1 = (Dali::Actor *)jarg1;
34574   arg2 = (float)jarg2;
34575   arg3 = (float)jarg3;
34576   arg4 = (float)jarg4;
34577   {
34578     try {
34579       (arg1)->SetPosition(arg2,arg3,arg4);
34580     } catch (std::out_of_range& e) {
34581       {
34582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34583       };
34584     } catch (std::exception& e) {
34585       {
34586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34587       };
34588     } catch (Dali::DaliException e) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34591       };
34592     } catch (...) {
34593       {
34594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34595       };
34596     }
34597   }
34598
34599 }
34600
34601
34602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34604   Dali::Vector3 *arg2 = 0 ;
34605
34606   arg1 = (Dali::Actor *)jarg1;
34607   arg2 = (Dali::Vector3 *)jarg2;
34608   if (!arg2) {
34609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34610     return ;
34611   }
34612   {
34613     try {
34614       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34615     } catch (std::out_of_range& e) {
34616       {
34617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34618       };
34619     } catch (std::exception& e) {
34620       {
34621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34622       };
34623     } catch (Dali::DaliException e) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34626       };
34627     } catch (...) {
34628       {
34629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34630       };
34631     }
34632   }
34633
34634 }
34635
34636
34637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34639   float arg2 ;
34640
34641   arg1 = (Dali::Actor *)jarg1;
34642   arg2 = (float)jarg2;
34643   {
34644     try {
34645       (arg1)->SetX(arg2);
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34653       };
34654     } catch (Dali::DaliException e) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34657       };
34658     } catch (...) {
34659       {
34660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34661       };
34662     }
34663   }
34664
34665 }
34666
34667
34668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34670   float arg2 ;
34671
34672   arg1 = (Dali::Actor *)jarg1;
34673   arg2 = (float)jarg2;
34674   {
34675     try {
34676       (arg1)->SetY(arg2);
34677     } catch (std::out_of_range& e) {
34678       {
34679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34680       };
34681     } catch (std::exception& e) {
34682       {
34683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34684       };
34685     } catch (Dali::DaliException e) {
34686       {
34687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34688       };
34689     } catch (...) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34692       };
34693     }
34694   }
34695
34696 }
34697
34698
34699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34701   float arg2 ;
34702
34703   arg1 = (Dali::Actor *)jarg1;
34704   arg2 = (float)jarg2;
34705   {
34706     try {
34707       (arg1)->SetZ(arg2);
34708     } catch (std::out_of_range& e) {
34709       {
34710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34711       };
34712     } catch (std::exception& e) {
34713       {
34714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (Dali::DaliException e) {
34717       {
34718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34719       };
34720     } catch (...) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34723       };
34724     }
34725   }
34726
34727 }
34728
34729
34730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34732   Dali::Vector3 *arg2 = 0 ;
34733
34734   arg1 = (Dali::Actor *)jarg1;
34735   arg2 = (Dali::Vector3 *)jarg2;
34736   if (!arg2) {
34737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34738     return ;
34739   }
34740   {
34741     try {
34742       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34743     } catch (std::out_of_range& e) {
34744       {
34745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34746       };
34747     } catch (std::exception& e) {
34748       {
34749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (Dali::DaliException e) {
34752       {
34753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34758       };
34759     }
34760   }
34761
34762 }
34763
34764
34765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34766   void * jresult ;
34767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34768   Dali::Vector3 result;
34769
34770   arg1 = (Dali::Actor *)jarg1;
34771   {
34772     try {
34773       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34774     } catch (std::out_of_range& e) {
34775       {
34776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34777       };
34778     } catch (std::exception& e) {
34779       {
34780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34781       };
34782     } catch (Dali::DaliException e) {
34783       {
34784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34785       };
34786     } catch (...) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34789       };
34790     }
34791   }
34792
34793   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34794   return jresult;
34795 }
34796
34797
34798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34799   void * jresult ;
34800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34801   Dali::Vector3 result;
34802
34803   arg1 = (Dali::Actor *)jarg1;
34804   {
34805     try {
34806       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (Dali::DaliException e) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34818       };
34819     } catch (...) {
34820       {
34821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34822       };
34823     }
34824   }
34825
34826   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34827   return jresult;
34828 }
34829
34830
34831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34833   bool arg2 ;
34834
34835   arg1 = (Dali::Actor *)jarg1;
34836   arg2 = jarg2 ? true : false;
34837   {
34838     try {
34839       (arg1)->SetInheritPosition(arg2);
34840     } catch (std::out_of_range& e) {
34841       {
34842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34843       };
34844     } catch (std::exception& e) {
34845       {
34846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34847       };
34848     } catch (Dali::DaliException e) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34855       };
34856     }
34857   }
34858
34859 }
34860
34861
34862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34863   int jresult ;
34864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34865   Dali::PositionInheritanceMode result;
34866
34867   arg1 = (Dali::Actor *)jarg1;
34868   {
34869     try {
34870       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34871     } catch (std::out_of_range& e) {
34872       {
34873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34874       };
34875     } catch (std::exception& e) {
34876       {
34877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (Dali::DaliException e) {
34880       {
34881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34882       };
34883     } catch (...) {
34884       {
34885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34886       };
34887     }
34888   }
34889
34890   jresult = (int)result;
34891   return jresult;
34892 }
34893
34894
34895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34896   unsigned int jresult ;
34897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34898   bool result;
34899
34900   arg1 = (Dali::Actor *)jarg1;
34901   {
34902     try {
34903       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34904     } catch (std::out_of_range& e) {
34905       {
34906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (std::exception& e) {
34909       {
34910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34911       };
34912     } catch (Dali::DaliException e) {
34913       {
34914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34915       };
34916     } catch (...) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34919       };
34920     }
34921   }
34922
34923   jresult = result;
34924   return jresult;
34925 }
34926
34927
34928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34930   Dali::Degree *arg2 = 0 ;
34931   Dali::Vector3 *arg3 = 0 ;
34932
34933   arg1 = (Dali::Actor *)jarg1;
34934   arg2 = (Dali::Degree *)jarg2;
34935   if (!arg2) {
34936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34937     return ;
34938   }
34939   arg3 = (Dali::Vector3 *)jarg3;
34940   if (!arg3) {
34941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34942     return ;
34943   }
34944   {
34945     try {
34946       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34947     } catch (std::out_of_range& e) {
34948       {
34949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34950       };
34951     } catch (std::exception& e) {
34952       {
34953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34954       };
34955     } catch (Dali::DaliException e) {
34956       {
34957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34958       };
34959     } catch (...) {
34960       {
34961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34962       };
34963     }
34964   }
34965
34966 }
34967
34968
34969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34971   Dali::Radian *arg2 = 0 ;
34972   Dali::Vector3 *arg3 = 0 ;
34973
34974   arg1 = (Dali::Actor *)jarg1;
34975   arg2 = (Dali::Radian *)jarg2;
34976   if (!arg2) {
34977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34978     return ;
34979   }
34980   arg3 = (Dali::Vector3 *)jarg3;
34981   if (!arg3) {
34982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34983     return ;
34984   }
34985   {
34986     try {
34987       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34988     } catch (std::out_of_range& e) {
34989       {
34990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (std::exception& e) {
34993       {
34994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34995       };
34996     } catch (Dali::DaliException e) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34999       };
35000     } catch (...) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35003       };
35004     }
35005   }
35006
35007 }
35008
35009
35010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35012   Dali::Quaternion *arg2 = 0 ;
35013
35014   arg1 = (Dali::Actor *)jarg1;
35015   arg2 = (Dali::Quaternion *)jarg2;
35016   if (!arg2) {
35017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35018     return ;
35019   }
35020   {
35021     try {
35022       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35023     } catch (std::out_of_range& e) {
35024       {
35025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35026       };
35027     } catch (std::exception& e) {
35028       {
35029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35030       };
35031     } catch (Dali::DaliException e) {
35032       {
35033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35038       };
35039     }
35040   }
35041
35042 }
35043
35044
35045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35047   Dali::Degree *arg2 = 0 ;
35048   Dali::Vector3 *arg3 = 0 ;
35049
35050   arg1 = (Dali::Actor *)jarg1;
35051   arg2 = (Dali::Degree *)jarg2;
35052   if (!arg2) {
35053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35054     return ;
35055   }
35056   arg3 = (Dali::Vector3 *)jarg3;
35057   if (!arg3) {
35058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35059     return ;
35060   }
35061   {
35062     try {
35063       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35064     } catch (std::out_of_range& e) {
35065       {
35066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35067       };
35068     } catch (std::exception& e) {
35069       {
35070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35071       };
35072     } catch (Dali::DaliException e) {
35073       {
35074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35075       };
35076     } catch (...) {
35077       {
35078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35079       };
35080     }
35081   }
35082
35083 }
35084
35085
35086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35088   Dali::Radian *arg2 = 0 ;
35089   Dali::Vector3 *arg3 = 0 ;
35090
35091   arg1 = (Dali::Actor *)jarg1;
35092   arg2 = (Dali::Radian *)jarg2;
35093   if (!arg2) {
35094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35095     return ;
35096   }
35097   arg3 = (Dali::Vector3 *)jarg3;
35098   if (!arg3) {
35099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35100     return ;
35101   }
35102   {
35103     try {
35104       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35105     } catch (std::out_of_range& e) {
35106       {
35107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35108       };
35109     } catch (std::exception& e) {
35110       {
35111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35112       };
35113     } catch (Dali::DaliException e) {
35114       {
35115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35116       };
35117     } catch (...) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35120       };
35121     }
35122   }
35123
35124 }
35125
35126
35127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35129   Dali::Quaternion *arg2 = 0 ;
35130
35131   arg1 = (Dali::Actor *)jarg1;
35132   arg2 = (Dali::Quaternion *)jarg2;
35133   if (!arg2) {
35134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35135     return ;
35136   }
35137   {
35138     try {
35139       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35140     } catch (std::out_of_range& e) {
35141       {
35142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35143       };
35144     } catch (std::exception& e) {
35145       {
35146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35147       };
35148     } catch (Dali::DaliException e) {
35149       {
35150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35151       };
35152     } catch (...) {
35153       {
35154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35155       };
35156     }
35157   }
35158
35159 }
35160
35161
35162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35163   void * jresult ;
35164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35165   Dali::Quaternion result;
35166
35167   arg1 = (Dali::Actor *)jarg1;
35168   {
35169     try {
35170       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35171     } catch (std::out_of_range& e) {
35172       {
35173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35174       };
35175     } catch (std::exception& e) {
35176       {
35177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35178       };
35179     } catch (Dali::DaliException e) {
35180       {
35181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35182       };
35183     } catch (...) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35186       };
35187     }
35188   }
35189
35190   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35191   return jresult;
35192 }
35193
35194
35195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35197   bool arg2 ;
35198
35199   arg1 = (Dali::Actor *)jarg1;
35200   arg2 = jarg2 ? true : false;
35201   {
35202     try {
35203       (arg1)->SetInheritOrientation(arg2);
35204     } catch (std::out_of_range& e) {
35205       {
35206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35207       };
35208     } catch (std::exception& e) {
35209       {
35210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35211       };
35212     } catch (Dali::DaliException e) {
35213       {
35214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35215       };
35216     } catch (...) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35219       };
35220     }
35221   }
35222
35223 }
35224
35225
35226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35227   unsigned int jresult ;
35228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35229   bool result;
35230
35231   arg1 = (Dali::Actor *)jarg1;
35232   {
35233     try {
35234       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35235     } catch (std::out_of_range& e) {
35236       {
35237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35238       };
35239     } catch (std::exception& e) {
35240       {
35241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35242       };
35243     } catch (Dali::DaliException e) {
35244       {
35245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35246       };
35247     } catch (...) {
35248       {
35249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35250       };
35251     }
35252   }
35253
35254   jresult = result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35260   void * jresult ;
35261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35262   Dali::Quaternion result;
35263
35264   arg1 = (Dali::Actor *)jarg1;
35265   {
35266     try {
35267       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35268     } catch (std::out_of_range& e) {
35269       {
35270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35271       };
35272     } catch (std::exception& e) {
35273       {
35274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35275       };
35276     } catch (Dali::DaliException e) {
35277       {
35278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35279       };
35280     } catch (...) {
35281       {
35282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35283       };
35284     }
35285   }
35286
35287   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35288   return jresult;
35289 }
35290
35291
35292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35294   float arg2 ;
35295
35296   arg1 = (Dali::Actor *)jarg1;
35297   arg2 = (float)jarg2;
35298   {
35299     try {
35300       (arg1)->SetScale(arg2);
35301     } catch (std::out_of_range& e) {
35302       {
35303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35304       };
35305     } catch (std::exception& e) {
35306       {
35307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35308       };
35309     } catch (Dali::DaliException e) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35312       };
35313     } catch (...) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35316       };
35317     }
35318   }
35319
35320 }
35321
35322
35323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35325   float arg2 ;
35326   float arg3 ;
35327   float arg4 ;
35328
35329   arg1 = (Dali::Actor *)jarg1;
35330   arg2 = (float)jarg2;
35331   arg3 = (float)jarg3;
35332   arg4 = (float)jarg4;
35333   {
35334     try {
35335       (arg1)->SetScale(arg2,arg3,arg4);
35336     } catch (std::out_of_range& e) {
35337       {
35338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (std::exception& e) {
35341       {
35342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35343       };
35344     } catch (Dali::DaliException e) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35347       };
35348     } catch (...) {
35349       {
35350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35351       };
35352     }
35353   }
35354
35355 }
35356
35357
35358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35360   Dali::Vector3 *arg2 = 0 ;
35361
35362   arg1 = (Dali::Actor *)jarg1;
35363   arg2 = (Dali::Vector3 *)jarg2;
35364   if (!arg2) {
35365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35366     return ;
35367   }
35368   {
35369     try {
35370       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35371     } catch (std::out_of_range& e) {
35372       {
35373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (std::exception& e) {
35376       {
35377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35378       };
35379     } catch (Dali::DaliException e) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35382       };
35383     } catch (...) {
35384       {
35385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35386       };
35387     }
35388   }
35389
35390 }
35391
35392
35393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35395   Dali::Vector3 *arg2 = 0 ;
35396
35397   arg1 = (Dali::Actor *)jarg1;
35398   arg2 = (Dali::Vector3 *)jarg2;
35399   if (!arg2) {
35400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35401     return ;
35402   }
35403   {
35404     try {
35405       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35406     } catch (std::out_of_range& e) {
35407       {
35408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35409       };
35410     } catch (std::exception& e) {
35411       {
35412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35413       };
35414     } catch (Dali::DaliException e) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35417       };
35418     } catch (...) {
35419       {
35420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35421       };
35422     }
35423   }
35424
35425 }
35426
35427
35428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35429   void * jresult ;
35430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35431   Dali::Vector3 result;
35432
35433   arg1 = (Dali::Actor *)jarg1;
35434   {
35435     try {
35436       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35437     } catch (std::out_of_range& e) {
35438       {
35439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35440       };
35441     } catch (std::exception& e) {
35442       {
35443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35444       };
35445     } catch (Dali::DaliException e) {
35446       {
35447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35448       };
35449     } catch (...) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35452       };
35453     }
35454   }
35455
35456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35457   return jresult;
35458 }
35459
35460
35461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35462   void * jresult ;
35463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35464   Dali::Vector3 result;
35465
35466   arg1 = (Dali::Actor *)jarg1;
35467   {
35468     try {
35469       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35470     } catch (std::out_of_range& e) {
35471       {
35472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (std::exception& e) {
35475       {
35476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (Dali::DaliException e) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35481       };
35482     } catch (...) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35485       };
35486     }
35487   }
35488
35489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35496   bool arg2 ;
35497
35498   arg1 = (Dali::Actor *)jarg1;
35499   arg2 = jarg2 ? true : false;
35500   {
35501     try {
35502       (arg1)->SetInheritScale(arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (Dali::DaliException e) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35514       };
35515     } catch (...) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35518       };
35519     }
35520   }
35521
35522 }
35523
35524
35525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35526   unsigned int jresult ;
35527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35528   bool result;
35529
35530   arg1 = (Dali::Actor *)jarg1;
35531   {
35532     try {
35533       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35534     } catch (std::out_of_range& e) {
35535       {
35536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35537       };
35538     } catch (std::exception& e) {
35539       {
35540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (Dali::DaliException e) {
35543       {
35544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35545       };
35546     } catch (...) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35549       };
35550     }
35551   }
35552
35553   jresult = result;
35554   return jresult;
35555 }
35556
35557
35558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35559   void * jresult ;
35560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35561   Dali::Matrix result;
35562
35563   arg1 = (Dali::Actor *)jarg1;
35564   {
35565     try {
35566       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35567     } catch (std::out_of_range& e) {
35568       {
35569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35570       };
35571     } catch (std::exception& e) {
35572       {
35573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35574       };
35575     } catch (Dali::DaliException e) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35578       };
35579     } catch (...) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35582       };
35583     }
35584   }
35585
35586   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35587   return jresult;
35588 }
35589
35590
35591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35593   bool arg2 ;
35594
35595   arg1 = (Dali::Actor *)jarg1;
35596   arg2 = jarg2 ? true : false;
35597   {
35598     try {
35599       (arg1)->SetVisible(arg2);
35600     } catch (std::out_of_range& e) {
35601       {
35602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35603       };
35604     } catch (std::exception& e) {
35605       {
35606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35607       };
35608     } catch (Dali::DaliException e) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35611       };
35612     } catch (...) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35615       };
35616     }
35617   }
35618
35619 }
35620
35621
35622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35623   unsigned int jresult ;
35624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35625   bool result;
35626
35627   arg1 = (Dali::Actor *)jarg1;
35628   {
35629     try {
35630       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (Dali::DaliException e) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35642       };
35643     } catch (...) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35646       };
35647     }
35648   }
35649
35650   jresult = result;
35651   return jresult;
35652 }
35653
35654
35655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35657   float arg2 ;
35658
35659   arg1 = (Dali::Actor *)jarg1;
35660   arg2 = (float)jarg2;
35661   {
35662     try {
35663       (arg1)->SetOpacity(arg2);
35664     } catch (std::out_of_range& e) {
35665       {
35666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35667       };
35668     } catch (std::exception& e) {
35669       {
35670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35671       };
35672     } catch (Dali::DaliException e) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35675       };
35676     } catch (...) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35679       };
35680     }
35681   }
35682
35683 }
35684
35685
35686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35687   float jresult ;
35688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35689   float result;
35690
35691   arg1 = (Dali::Actor *)jarg1;
35692   {
35693     try {
35694       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35695     } catch (std::out_of_range& e) {
35696       {
35697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35698       };
35699     } catch (std::exception& e) {
35700       {
35701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (Dali::DaliException e) {
35704       {
35705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35706       };
35707     } catch (...) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35710       };
35711     }
35712   }
35713
35714   jresult = result;
35715   return jresult;
35716 }
35717
35718
35719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35721   Dali::Vector4 *arg2 = 0 ;
35722
35723   arg1 = (Dali::Actor *)jarg1;
35724   arg2 = (Dali::Vector4 *)jarg2;
35725   if (!arg2) {
35726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35727     return ;
35728   }
35729   {
35730     try {
35731       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35732     } catch (std::out_of_range& e) {
35733       {
35734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (std::exception& e) {
35737       {
35738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35739       };
35740     } catch (Dali::DaliException e) {
35741       {
35742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35743       };
35744     } catch (...) {
35745       {
35746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35747       };
35748     }
35749   }
35750
35751 }
35752
35753
35754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35755   void * jresult ;
35756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35757   Dali::Vector4 result;
35758
35759   arg1 = (Dali::Actor *)jarg1;
35760   {
35761     try {
35762       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35763     } catch (std::out_of_range& e) {
35764       {
35765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35766       };
35767     } catch (std::exception& e) {
35768       {
35769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35770       };
35771     } catch (Dali::DaliException e) {
35772       {
35773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35774       };
35775     } catch (...) {
35776       {
35777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35778       };
35779     }
35780   }
35781
35782   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35783   return jresult;
35784 }
35785
35786
35787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35789   Dali::ColorMode arg2 ;
35790
35791   arg1 = (Dali::Actor *)jarg1;
35792   arg2 = (Dali::ColorMode)jarg2;
35793   {
35794     try {
35795       (arg1)->SetColorMode(arg2);
35796     } catch (std::out_of_range& e) {
35797       {
35798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35799       };
35800     } catch (std::exception& e) {
35801       {
35802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (Dali::DaliException e) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35807       };
35808     } catch (...) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35811       };
35812     }
35813   }
35814
35815 }
35816
35817
35818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35819   int jresult ;
35820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35821   Dali::ColorMode result;
35822
35823   arg1 = (Dali::Actor *)jarg1;
35824   {
35825     try {
35826       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35827     } catch (std::out_of_range& e) {
35828       {
35829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35830       };
35831     } catch (std::exception& e) {
35832       {
35833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (Dali::DaliException e) {
35836       {
35837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35842       };
35843     }
35844   }
35845
35846   jresult = (int)result;
35847   return jresult;
35848 }
35849
35850
35851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35852   void * jresult ;
35853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35854   Dali::Vector4 result;
35855
35856   arg1 = (Dali::Actor *)jarg1;
35857   {
35858     try {
35859       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35860     } catch (std::out_of_range& e) {
35861       {
35862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35863       };
35864     } catch (std::exception& e) {
35865       {
35866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35867       };
35868     } catch (Dali::DaliException e) {
35869       {
35870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35871       };
35872     } catch (...) {
35873       {
35874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35875       };
35876     }
35877   }
35878
35879   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35880   return jresult;
35881 }
35882
35883
35884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35886   Dali::DrawMode::Type arg2 ;
35887
35888   arg1 = (Dali::Actor *)jarg1;
35889   arg2 = (Dali::DrawMode::Type)jarg2;
35890   {
35891     try {
35892       (arg1)->SetDrawMode(arg2);
35893     } catch (std::out_of_range& e) {
35894       {
35895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35896       };
35897     } catch (std::exception& e) {
35898       {
35899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35900       };
35901     } catch (Dali::DaliException e) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35904       };
35905     } catch (...) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35908       };
35909     }
35910   }
35911
35912 }
35913
35914
35915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35916   int jresult ;
35917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35918   Dali::DrawMode::Type result;
35919
35920   arg1 = (Dali::Actor *)jarg1;
35921   {
35922     try {
35923       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35924     } catch (std::out_of_range& e) {
35925       {
35926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35927       };
35928     } catch (std::exception& e) {
35929       {
35930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (Dali::DaliException e) {
35933       {
35934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35935       };
35936     } catch (...) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35939       };
35940     }
35941   }
35942
35943   jresult = (int)result;
35944   return jresult;
35945 }
35946
35947
35948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35950   bool arg2 ;
35951
35952   arg1 = (Dali::Actor *)jarg1;
35953   arg2 = jarg2 ? true : false;
35954   {
35955     try {
35956       (arg1)->SetSensitive(arg2);
35957     } catch (std::out_of_range& e) {
35958       {
35959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35960       };
35961     } catch (std::exception& e) {
35962       {
35963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35964       };
35965     } catch (Dali::DaliException e) {
35966       {
35967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35968       };
35969     } catch (...) {
35970       {
35971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35972       };
35973     }
35974   }
35975
35976 }
35977
35978
35979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35980   unsigned int jresult ;
35981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35982   bool result;
35983
35984   arg1 = (Dali::Actor *)jarg1;
35985   {
35986     try {
35987       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35988     } catch (std::out_of_range& e) {
35989       {
35990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35991       };
35992     } catch (std::exception& e) {
35993       {
35994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35995       };
35996     } catch (Dali::DaliException e) {
35997       {
35998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35999       };
36000     } catch (...) {
36001       {
36002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36003       };
36004     }
36005   }
36006
36007   jresult = result;
36008   return jresult;
36009 }
36010
36011
36012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36013   unsigned int jresult ;
36014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36015   float *arg2 = 0 ;
36016   float *arg3 = 0 ;
36017   float arg4 ;
36018   float arg5 ;
36019   bool result;
36020
36021   arg1 = (Dali::Actor *)jarg1;
36022   arg2 = (float *)jarg2;
36023   arg3 = (float *)jarg3;
36024   arg4 = (float)jarg4;
36025   arg5 = (float)jarg5;
36026   {
36027     try {
36028       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36029     } catch (std::out_of_range& e) {
36030       {
36031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36032       };
36033     } catch (std::exception& e) {
36034       {
36035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36036       };
36037     } catch (Dali::DaliException e) {
36038       {
36039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36044       };
36045     }
36046   }
36047
36048   jresult = result;
36049   return jresult;
36050 }
36051
36052
36053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36055   bool arg2 ;
36056
36057   arg1 = (Dali::Actor *)jarg1;
36058   arg2 = jarg2 ? true : false;
36059   {
36060     try {
36061       (arg1)->SetLeaveRequired(arg2);
36062     } catch (std::out_of_range& e) {
36063       {
36064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36065       };
36066     } catch (std::exception& e) {
36067       {
36068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36069       };
36070     } catch (Dali::DaliException e) {
36071       {
36072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36073       };
36074     } catch (...) {
36075       {
36076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36077       };
36078     }
36079   }
36080
36081 }
36082
36083
36084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36085   unsigned int jresult ;
36086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36087   bool result;
36088
36089   arg1 = (Dali::Actor *)jarg1;
36090   {
36091     try {
36092       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36093     } catch (std::out_of_range& e) {
36094       {
36095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36096       };
36097     } catch (std::exception& e) {
36098       {
36099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36100       };
36101     } catch (Dali::DaliException e) {
36102       {
36103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36104       };
36105     } catch (...) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36108       };
36109     }
36110   }
36111
36112   jresult = result;
36113   return jresult;
36114 }
36115
36116
36117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36119   bool arg2 ;
36120
36121   arg1 = (Dali::Actor *)jarg1;
36122   arg2 = jarg2 ? true : false;
36123   {
36124     try {
36125       (arg1)->SetKeyboardFocusable(arg2);
36126     } catch (std::out_of_range& e) {
36127       {
36128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36129       };
36130     } catch (std::exception& e) {
36131       {
36132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36133       };
36134     } catch (Dali::DaliException e) {
36135       {
36136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36137       };
36138     } catch (...) {
36139       {
36140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36141       };
36142     }
36143   }
36144
36145 }
36146
36147
36148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36149   unsigned int jresult ;
36150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36151   bool result;
36152
36153   arg1 = (Dali::Actor *)jarg1;
36154   {
36155     try {
36156       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36157     } catch (std::out_of_range& e) {
36158       {
36159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36160       };
36161     } catch (std::exception& e) {
36162       {
36163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36164       };
36165     } catch (Dali::DaliException e) {
36166       {
36167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36168       };
36169     } catch (...) {
36170       {
36171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36172       };
36173     }
36174   }
36175
36176   jresult = result;
36177   return jresult;
36178 }
36179
36180
36181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36183   Dali::ResizePolicy::Type arg2 ;
36184   Dali::Dimension::Type arg3 ;
36185
36186   arg1 = (Dali::Actor *)jarg1;
36187   arg2 = (Dali::ResizePolicy::Type)jarg2;
36188   arg3 = (Dali::Dimension::Type)jarg3;
36189   {
36190     try {
36191       (arg1)->SetResizePolicy(arg2,arg3);
36192     } catch (std::out_of_range& e) {
36193       {
36194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36195       };
36196     } catch (std::exception& e) {
36197       {
36198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36199       };
36200     } catch (Dali::DaliException e) {
36201       {
36202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36203       };
36204     } catch (...) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36207       };
36208     }
36209   }
36210
36211 }
36212
36213
36214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36215   int jresult ;
36216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36217   Dali::Dimension::Type arg2 ;
36218   Dali::ResizePolicy::Type result;
36219
36220   arg1 = (Dali::Actor *)jarg1;
36221   arg2 = (Dali::Dimension::Type)jarg2;
36222   {
36223     try {
36224       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36225     } catch (std::out_of_range& e) {
36226       {
36227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36228       };
36229     } catch (std::exception& e) {
36230       {
36231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (Dali::DaliException e) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36236       };
36237     } catch (...) {
36238       {
36239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36240       };
36241     }
36242   }
36243
36244   jresult = (int)result;
36245   return jresult;
36246 }
36247
36248
36249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36251   Dali::SizeScalePolicy::Type arg2 ;
36252
36253   arg1 = (Dali::Actor *)jarg1;
36254   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36255   {
36256     try {
36257       (arg1)->SetSizeScalePolicy(arg2);
36258     } catch (std::out_of_range& e) {
36259       {
36260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36261       };
36262     } catch (std::exception& e) {
36263       {
36264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36265       };
36266     } catch (Dali::DaliException e) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36269       };
36270     } catch (...) {
36271       {
36272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36273       };
36274     }
36275   }
36276
36277 }
36278
36279
36280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36281   int jresult ;
36282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36283   Dali::SizeScalePolicy::Type result;
36284
36285   arg1 = (Dali::Actor *)jarg1;
36286   {
36287     try {
36288       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36289     } catch (std::out_of_range& e) {
36290       {
36291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36292       };
36293     } catch (std::exception& e) {
36294       {
36295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36296       };
36297     } catch (Dali::DaliException e) {
36298       {
36299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36300       };
36301     } catch (...) {
36302       {
36303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36304       };
36305     }
36306   }
36307
36308   jresult = (int)result;
36309   return jresult;
36310 }
36311
36312
36313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36315   Dali::Vector3 *arg2 = 0 ;
36316
36317   arg1 = (Dali::Actor *)jarg1;
36318   arg2 = (Dali::Vector3 *)jarg2;
36319   if (!arg2) {
36320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36321     return ;
36322   }
36323   {
36324     try {
36325       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36326     } catch (std::out_of_range& e) {
36327       {
36328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (std::exception& e) {
36331       {
36332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36333       };
36334     } catch (Dali::DaliException e) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36337       };
36338     } catch (...) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36341       };
36342     }
36343   }
36344
36345 }
36346
36347
36348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36349   void * jresult ;
36350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36351   Dali::Vector3 result;
36352
36353   arg1 = (Dali::Actor *)jarg1;
36354   {
36355     try {
36356       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (Dali::DaliException e) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36368       };
36369     } catch (...) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36372       };
36373     }
36374   }
36375
36376   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36377   return jresult;
36378 }
36379
36380
36381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36382   float jresult ;
36383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36384   float arg2 ;
36385   float result;
36386
36387   arg1 = (Dali::Actor *)jarg1;
36388   arg2 = (float)jarg2;
36389   {
36390     try {
36391       result = (float)(arg1)->GetHeightForWidth(arg2);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (Dali::DaliException e) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36403       };
36404     } catch (...) {
36405       {
36406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36407       };
36408     }
36409   }
36410
36411   jresult = result;
36412   return jresult;
36413 }
36414
36415
36416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36417   float jresult ;
36418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36419   float arg2 ;
36420   float result;
36421
36422   arg1 = (Dali::Actor *)jarg1;
36423   arg2 = (float)jarg2;
36424   {
36425     try {
36426       result = (float)(arg1)->GetWidthForHeight(arg2);
36427     } catch (std::out_of_range& e) {
36428       {
36429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (std::exception& e) {
36432       {
36433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36434       };
36435     } catch (Dali::DaliException e) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36438       };
36439     } catch (...) {
36440       {
36441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36442       };
36443     }
36444   }
36445
36446   jresult = result;
36447   return jresult;
36448 }
36449
36450
36451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36452   float jresult ;
36453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36454   Dali::Dimension::Type arg2 ;
36455   float result;
36456
36457   arg1 = (Dali::Actor *)jarg1;
36458   arg2 = (Dali::Dimension::Type)jarg2;
36459   {
36460     try {
36461       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36462     } catch (std::out_of_range& e) {
36463       {
36464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36465       };
36466     } catch (std::exception& e) {
36467       {
36468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (Dali::DaliException e) {
36471       {
36472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36473       };
36474     } catch (...) {
36475       {
36476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36477       };
36478     }
36479   }
36480
36481   jresult = result;
36482   return jresult;
36483 }
36484
36485
36486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36488   Dali::Padding *arg2 = 0 ;
36489
36490   arg1 = (Dali::Actor *)jarg1;
36491   arg2 = (Dali::Padding *)jarg2;
36492   if (!arg2) {
36493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36494     return ;
36495   }
36496   {
36497     try {
36498       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36499     } catch (std::out_of_range& e) {
36500       {
36501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36502       };
36503     } catch (std::exception& e) {
36504       {
36505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36506       };
36507     } catch (Dali::DaliException e) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36510       };
36511     } catch (...) {
36512       {
36513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36514       };
36515     }
36516   }
36517
36518 }
36519
36520
36521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36523   Dali::Padding *arg2 = 0 ;
36524
36525   arg1 = (Dali::Actor *)jarg1;
36526   arg2 = (Dali::Padding *)jarg2;
36527   if (!arg2) {
36528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36529     return ;
36530   }
36531   {
36532     try {
36533       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36534     } catch (std::out_of_range& e) {
36535       {
36536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36537       };
36538     } catch (std::exception& e) {
36539       {
36540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36541       };
36542     } catch (Dali::DaliException e) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36545       };
36546     } catch (...) {
36547       {
36548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36549       };
36550     }
36551   }
36552
36553 }
36554
36555
36556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36558   Dali::Vector2 *arg2 = 0 ;
36559
36560   arg1 = (Dali::Actor *)jarg1;
36561   arg2 = (Dali::Vector2 *)jarg2;
36562   if (!arg2) {
36563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36564     return ;
36565   }
36566   {
36567     try {
36568       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36569     } catch (std::out_of_range& e) {
36570       {
36571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36572       };
36573     } catch (std::exception& e) {
36574       {
36575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36576       };
36577     } catch (Dali::DaliException e) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36580       };
36581     } catch (...) {
36582       {
36583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36584       };
36585     }
36586   }
36587
36588 }
36589
36590
36591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36592   void * jresult ;
36593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36594   Dali::Vector2 result;
36595
36596   arg1 = (Dali::Actor *)jarg1;
36597   {
36598     try {
36599       result = (arg1)->GetMinimumSize();
36600     } catch (std::out_of_range& e) {
36601       {
36602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36603       };
36604     } catch (std::exception& e) {
36605       {
36606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (Dali::DaliException e) {
36609       {
36610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36615       };
36616     }
36617   }
36618
36619   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36620   return jresult;
36621 }
36622
36623
36624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36626   Dali::Vector2 *arg2 = 0 ;
36627
36628   arg1 = (Dali::Actor *)jarg1;
36629   arg2 = (Dali::Vector2 *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36632     return ;
36633   }
36634   {
36635     try {
36636       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36644       };
36645     } catch (Dali::DaliException e) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36648       };
36649     } catch (...) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36652       };
36653     }
36654   }
36655
36656 }
36657
36658
36659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36660   void * jresult ;
36661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36662   Dali::Vector2 result;
36663
36664   arg1 = (Dali::Actor *)jarg1;
36665   {
36666     try {
36667       result = (arg1)->GetMaximumSize();
36668     } catch (std::out_of_range& e) {
36669       {
36670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (std::exception& e) {
36673       {
36674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (Dali::DaliException e) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36683       };
36684     }
36685   }
36686
36687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36693   int jresult ;
36694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36695   int result;
36696
36697   arg1 = (Dali::Actor *)jarg1;
36698   {
36699     try {
36700       result = (int)(arg1)->GetHierarchyDepth();
36701     } catch (std::out_of_range& e) {
36702       {
36703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (std::exception& e) {
36706       {
36707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (Dali::DaliException e) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36726   unsigned int jresult ;
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   Dali::Renderer *arg2 = 0 ;
36729   unsigned int result;
36730
36731   arg1 = (Dali::Actor *)jarg1;
36732   arg2 = (Dali::Renderer *)jarg2;
36733   if (!arg2) {
36734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36735     return 0;
36736   }
36737   {
36738     try {
36739       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36740     } catch (std::out_of_range& e) {
36741       {
36742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (std::exception& e) {
36745       {
36746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36747       };
36748     } catch (Dali::DaliException e) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36751       };
36752     } catch (...) {
36753       {
36754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36755       };
36756     }
36757   }
36758
36759   jresult = result;
36760   return jresult;
36761 }
36762
36763
36764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36765   unsigned int jresult ;
36766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36767   unsigned int result;
36768
36769   arg1 = (Dali::Actor *)jarg1;
36770   {
36771     try {
36772       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36773     } catch (std::out_of_range& e) {
36774       {
36775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (std::exception& e) {
36778       {
36779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36780       };
36781     } catch (Dali::DaliException e) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36784       };
36785     } catch (...) {
36786       {
36787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36788       };
36789     }
36790   }
36791
36792   jresult = result;
36793   return jresult;
36794 }
36795
36796
36797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36798   void * jresult ;
36799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36800   unsigned int arg2 ;
36801   Dali::Renderer result;
36802
36803   arg1 = (Dali::Actor *)jarg1;
36804   arg2 = (unsigned int)jarg2;
36805   {
36806     try {
36807       result = (arg1)->GetRendererAt(arg2);
36808     } catch (std::out_of_range& e) {
36809       {
36810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36811       };
36812     } catch (std::exception& e) {
36813       {
36814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36815       };
36816     } catch (Dali::DaliException e) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36819       };
36820     } catch (...) {
36821       {
36822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36823       };
36824     }
36825   }
36826
36827   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36828   return jresult;
36829 }
36830
36831
36832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36834   Dali::Renderer *arg2 = 0 ;
36835
36836   arg1 = (Dali::Actor *)jarg1;
36837   arg2 = (Dali::Renderer *)jarg2;
36838   if (!arg2) {
36839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36840     return ;
36841   }
36842   {
36843     try {
36844       (arg1)->RemoveRenderer(*arg2);
36845     } catch (std::out_of_range& e) {
36846       {
36847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36848       };
36849     } catch (std::exception& e) {
36850       {
36851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36852       };
36853     } catch (Dali::DaliException e) {
36854       {
36855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36856       };
36857     } catch (...) {
36858       {
36859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36860       };
36861     }
36862   }
36863
36864 }
36865
36866
36867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36869   unsigned int arg2 ;
36870
36871   arg1 = (Dali::Actor *)jarg1;
36872   arg2 = (unsigned int)jarg2;
36873   {
36874     try {
36875       (arg1)->RemoveRenderer(arg2);
36876     } catch (std::out_of_range& e) {
36877       {
36878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36879       };
36880     } catch (std::exception& e) {
36881       {
36882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36883       };
36884     } catch (Dali::DaliException e) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36887       };
36888     } catch (...) {
36889       {
36890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36891       };
36892     }
36893   }
36894
36895 }
36896
36897
36898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36899   void * jresult ;
36900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36901   Dali::Actor::TouchSignalType *result = 0 ;
36902
36903   arg1 = (Dali::Actor *)jarg1;
36904   {
36905     try {
36906       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36907     } catch (std::out_of_range& e) {
36908       {
36909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (std::exception& e) {
36912       {
36913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36914       };
36915     } catch (Dali::DaliException e) {
36916       {
36917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36918       };
36919     } catch (...) {
36920       {
36921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36922       };
36923     }
36924   }
36925
36926   jresult = (void *)result;
36927   return jresult;
36928 }
36929
36930
36931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36932   void * jresult ;
36933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36934   Dali::Actor::TouchDataSignalType *result = 0 ;
36935
36936   arg1 = (Dali::Actor *)jarg1;
36937   {
36938     try {
36939       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36940     } catch (std::out_of_range& e) {
36941       {
36942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (std::exception& e) {
36945       {
36946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36947       };
36948     } catch (Dali::DaliException e) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36951       };
36952     } catch (...) {
36953       {
36954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36955       };
36956     }
36957   }
36958
36959   jresult = (void *)result;
36960   return jresult;
36961 }
36962
36963
36964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36965   void * jresult ;
36966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36967   Dali::Actor::HoverSignalType *result = 0 ;
36968
36969   arg1 = (Dali::Actor *)jarg1;
36970   {
36971     try {
36972       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36973     } catch (std::out_of_range& e) {
36974       {
36975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36976       };
36977     } catch (std::exception& e) {
36978       {
36979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36980       };
36981     } catch (Dali::DaliException e) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36984       };
36985     } catch (...) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36988       };
36989     }
36990   }
36991
36992   jresult = (void *)result;
36993   return jresult;
36994 }
36995
36996
36997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36998   void * jresult ;
36999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37000   Dali::Actor::WheelEventSignalType *result = 0 ;
37001
37002   arg1 = (Dali::Actor *)jarg1;
37003   {
37004     try {
37005       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37006     } catch (std::out_of_range& e) {
37007       {
37008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (std::exception& e) {
37011       {
37012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (Dali::DaliException e) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37017       };
37018     } catch (...) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37021       };
37022     }
37023   }
37024
37025   jresult = (void *)result;
37026   return jresult;
37027 }
37028
37029
37030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37031   void * jresult ;
37032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37033   Dali::Actor::OnStageSignalType *result = 0 ;
37034
37035   arg1 = (Dali::Actor *)jarg1;
37036   {
37037     try {
37038       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37039     } catch (std::out_of_range& e) {
37040       {
37041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (std::exception& e) {
37044       {
37045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (Dali::DaliException e) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37050       };
37051     } catch (...) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37054       };
37055     }
37056   }
37057
37058   jresult = (void *)result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37064   void * jresult ;
37065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37066   Dali::Actor::OffStageSignalType *result = 0 ;
37067
37068   arg1 = (Dali::Actor *)jarg1;
37069   {
37070     try {
37071       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37072     } catch (std::out_of_range& e) {
37073       {
37074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (std::exception& e) {
37077       {
37078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (Dali::DaliException e) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37083       };
37084     } catch (...) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37087       };
37088     }
37089   }
37090
37091   jresult = (void *)result;
37092   return jresult;
37093 }
37094
37095
37096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37097   void * jresult ;
37098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37099   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37100
37101   arg1 = (Dali::Actor *)jarg1;
37102   {
37103     try {
37104       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37105     } catch (std::out_of_range& e) {
37106       {
37107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (std::exception& e) {
37110       {
37111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37112       };
37113     } catch (Dali::DaliException e) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37120       };
37121     }
37122   }
37123
37124   jresult = (void *)result;
37125   return jresult;
37126 }
37127
37128
37129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37130   Dali::Actor *arg1 = 0 ;
37131
37132   arg1 = (Dali::Actor *)jarg1;
37133   if (!arg1) {
37134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37135     return ;
37136   }
37137   {
37138     try {
37139       Dali::UnparentAndReset(*arg1);
37140     } catch (std::out_of_range& e) {
37141       {
37142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37143       };
37144     } catch (std::exception& e) {
37145       {
37146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37147       };
37148     } catch (Dali::DaliException e) {
37149       {
37150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37151       };
37152     } catch (...) {
37153       {
37154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37155       };
37156     }
37157   }
37158
37159 }
37160
37161
37162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37163   int jresult ;
37164   int result;
37165
37166   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37167   jresult = (int)result;
37168   return jresult;
37169 }
37170
37171
37172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37173   int jresult ;
37174   int result;
37175
37176   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37177   jresult = (int)result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37183   int jresult ;
37184   int result;
37185
37186   result = (int)Dali::Layer::Property::BEHAVIOR;
37187   jresult = (int)result;
37188   return jresult;
37189 }
37190
37191
37192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37193   void * jresult ;
37194   Dali::Layer::Property *result = 0 ;
37195
37196   {
37197     try {
37198       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37206       };
37207     } catch (Dali::DaliException e) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37210       };
37211     } catch (...) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37214       };
37215     }
37216   }
37217
37218   jresult = (void *)result;
37219   return jresult;
37220 }
37221
37222
37223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37224   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37225
37226   arg1 = (Dali::Layer::Property *)jarg1;
37227   {
37228     try {
37229       delete arg1;
37230     } catch (std::out_of_range& e) {
37231       {
37232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37233       };
37234     } catch (std::exception& e) {
37235       {
37236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37237       };
37238     } catch (Dali::DaliException e) {
37239       {
37240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37241       };
37242     } catch (...) {
37243       {
37244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37245       };
37246     }
37247   }
37248
37249 }
37250
37251
37252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37253   void * jresult ;
37254   Dali::Layer *result = 0 ;
37255
37256   {
37257     try {
37258       result = (Dali::Layer *)new Dali::Layer();
37259     } catch (std::out_of_range& e) {
37260       {
37261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37262       };
37263     } catch (std::exception& e) {
37264       {
37265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37266       };
37267     } catch (Dali::DaliException e) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37270       };
37271     } catch (...) {
37272       {
37273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37274       };
37275     }
37276   }
37277
37278   jresult = (void *)result;
37279   return jresult;
37280 }
37281
37282
37283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37284   void * jresult ;
37285   Dali::Layer result;
37286
37287   {
37288     try {
37289       result = Dali::Layer::New();
37290     } catch (std::out_of_range& e) {
37291       {
37292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37293       };
37294     } catch (std::exception& e) {
37295       {
37296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (Dali::DaliException e) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308
37309   jresult = new Dali::Layer((const Dali::Layer &)result);
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37315   void * jresult ;
37316   Dali::BaseHandle arg1 ;
37317   Dali::BaseHandle *argp1 ;
37318   Dali::Layer result;
37319
37320   argp1 = (Dali::BaseHandle *)jarg1;
37321   if (!argp1) {
37322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37323     return 0;
37324   }
37325   arg1 = *argp1;
37326   {
37327     try {
37328       result = Dali::Layer::DownCast(arg1);
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37336       };
37337     } catch (Dali::DaliException e) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37340       };
37341     } catch (...) {
37342       {
37343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37344       };
37345     }
37346   }
37347
37348   jresult = new Dali::Layer((const Dali::Layer &)result);
37349   return jresult;
37350 }
37351
37352
37353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37354   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37355
37356   arg1 = (Dali::Layer *)jarg1;
37357   {
37358     try {
37359       delete arg1;
37360     } catch (std::out_of_range& e) {
37361       {
37362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37363       };
37364     } catch (std::exception& e) {
37365       {
37366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37367       };
37368     } catch (Dali::DaliException e) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37371       };
37372     } catch (...) {
37373       {
37374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37375       };
37376     }
37377   }
37378
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37383   void * jresult ;
37384   Dali::Layer *arg1 = 0 ;
37385   Dali::Layer *result = 0 ;
37386
37387   arg1 = (Dali::Layer *)jarg1;
37388   if (!arg1) {
37389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37390     return 0;
37391   }
37392   {
37393     try {
37394       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37395     } catch (std::out_of_range& e) {
37396       {
37397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (std::exception& e) {
37400       {
37401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (Dali::DaliException e) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37406       };
37407     } catch (...) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37410       };
37411     }
37412   }
37413
37414   jresult = (void *)result;
37415   return jresult;
37416 }
37417
37418
37419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37420   void * jresult ;
37421   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37422   Dali::Layer *arg2 = 0 ;
37423   Dali::Layer *result = 0 ;
37424
37425   arg1 = (Dali::Layer *)jarg1;
37426   arg2 = (Dali::Layer *)jarg2;
37427   if (!arg2) {
37428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37429     return 0;
37430   }
37431   {
37432     try {
37433       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37434     } catch (std::out_of_range& e) {
37435       {
37436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37437       };
37438     } catch (std::exception& e) {
37439       {
37440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37441       };
37442     } catch (Dali::DaliException e) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37445       };
37446     } catch (...) {
37447       {
37448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37449       };
37450     }
37451   }
37452
37453   jresult = (void *)result;
37454   return jresult;
37455 }
37456
37457
37458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37459   unsigned int jresult ;
37460   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37461   unsigned int result;
37462
37463   arg1 = (Dali::Layer *)jarg1;
37464   {
37465     try {
37466       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37467     } catch (std::out_of_range& e) {
37468       {
37469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37470       };
37471     } catch (std::exception& e) {
37472       {
37473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37474       };
37475     } catch (Dali::DaliException e) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37478       };
37479     } catch (...) {
37480       {
37481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37482       };
37483     }
37484   }
37485
37486   jresult = result;
37487   return jresult;
37488 }
37489
37490
37491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37492   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37493
37494   arg1 = (Dali::Layer *)jarg1;
37495   {
37496     try {
37497       (arg1)->Raise();
37498     } catch (std::out_of_range& e) {
37499       {
37500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37501       };
37502     } catch (std::exception& e) {
37503       {
37504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37505       };
37506     } catch (Dali::DaliException e) {
37507       {
37508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37509       };
37510     } catch (...) {
37511       {
37512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37513       };
37514     }
37515   }
37516
37517 }
37518
37519
37520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37521   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37522
37523   arg1 = (Dali::Layer *)jarg1;
37524   {
37525     try {
37526       (arg1)->Lower();
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37542       };
37543     }
37544   }
37545
37546 }
37547
37548
37549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37550   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37551   Dali::Layer arg2 ;
37552   Dali::Layer *argp2 ;
37553
37554   arg1 = (Dali::Layer *)jarg1;
37555   argp2 = (Dali::Layer *)jarg2;
37556   if (!argp2) {
37557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37558     return ;
37559   }
37560   arg2 = *argp2;
37561   {
37562     try {
37563       (arg1)->RaiseAbove(arg2);
37564     } catch (std::out_of_range& e) {
37565       {
37566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37567       };
37568     } catch (std::exception& e) {
37569       {
37570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37571       };
37572     } catch (Dali::DaliException e) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37579       };
37580     }
37581   }
37582
37583 }
37584
37585
37586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37587   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37588   Dali::Layer arg2 ;
37589   Dali::Layer *argp2 ;
37590
37591   arg1 = (Dali::Layer *)jarg1;
37592   argp2 = (Dali::Layer *)jarg2;
37593   if (!argp2) {
37594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37595     return ;
37596   }
37597   arg2 = *argp2;
37598   {
37599     try {
37600       (arg1)->LowerBelow(arg2);
37601     } catch (std::out_of_range& e) {
37602       {
37603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37604       };
37605     } catch (std::exception& e) {
37606       {
37607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37608       };
37609     } catch (Dali::DaliException e) {
37610       {
37611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37612       };
37613     } catch (...) {
37614       {
37615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37616       };
37617     }
37618   }
37619
37620 }
37621
37622
37623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37625
37626   arg1 = (Dali::Layer *)jarg1;
37627   {
37628     try {
37629       (arg1)->RaiseToTop();
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   {
37657     try {
37658       (arg1)->LowerToBottom();
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer arg2 ;
37684   Dali::Layer *argp2 ;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   argp2 = (Dali::Layer *)jarg2;
37688   if (!argp2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37690     return ;
37691   }
37692   arg2 = *argp2;
37693   {
37694     try {
37695       (arg1)->MoveAbove(arg2);
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720   Dali::Layer arg2 ;
37721   Dali::Layer *argp2 ;
37722
37723   arg1 = (Dali::Layer *)jarg1;
37724   argp2 = (Dali::Layer *)jarg2;
37725   if (!argp2) {
37726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37727     return ;
37728   }
37729   arg2 = *argp2;
37730   {
37731     try {
37732       (arg1)->MoveBelow(arg2);
37733     } catch (std::out_of_range& e) {
37734       {
37735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (std::exception& e) {
37738       {
37739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37740       };
37741     } catch (Dali::DaliException e) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37748       };
37749     }
37750   }
37751
37752 }
37753
37754
37755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37756   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37757   Dali::Layer::Behavior arg2 ;
37758
37759   arg1 = (Dali::Layer *)jarg1;
37760   arg2 = (Dali::Layer::Behavior)jarg2;
37761   {
37762     try {
37763       (arg1)->SetBehavior(arg2);
37764     } catch (std::out_of_range& e) {
37765       {
37766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37767       };
37768     } catch (std::exception& e) {
37769       {
37770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37771       };
37772     } catch (Dali::DaliException e) {
37773       {
37774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37775       };
37776     } catch (...) {
37777       {
37778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37779       };
37780     }
37781   }
37782
37783 }
37784
37785
37786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37787   int jresult ;
37788   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37789   Dali::Layer::Behavior result;
37790
37791   arg1 = (Dali::Layer *)jarg1;
37792   {
37793     try {
37794       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37795     } catch (std::out_of_range& e) {
37796       {
37797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37798       };
37799     } catch (std::exception& e) {
37800       {
37801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37802       };
37803     } catch (Dali::DaliException e) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37806       };
37807     } catch (...) {
37808       {
37809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37810       };
37811     }
37812   }
37813
37814   jresult = (int)result;
37815   return jresult;
37816 }
37817
37818
37819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37820   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37821   bool arg2 ;
37822
37823   arg1 = (Dali::Layer *)jarg1;
37824   arg2 = jarg2 ? true : false;
37825   {
37826     try {
37827       (arg1)->SetClipping(arg2);
37828     } catch (std::out_of_range& e) {
37829       {
37830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37831       };
37832     } catch (std::exception& e) {
37833       {
37834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37835       };
37836     } catch (Dali::DaliException e) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37843       };
37844     }
37845   }
37846
37847 }
37848
37849
37850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37851   unsigned int jresult ;
37852   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37853   bool result;
37854
37855   arg1 = (Dali::Layer *)jarg1;
37856   {
37857     try {
37858       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37859     } catch (std::out_of_range& e) {
37860       {
37861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37862       };
37863     } catch (std::exception& e) {
37864       {
37865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37866       };
37867     } catch (Dali::DaliException e) {
37868       {
37869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37870       };
37871     } catch (...) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37874       };
37875     }
37876   }
37877
37878   jresult = result;
37879   return jresult;
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37884   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37885   int arg2 ;
37886   int arg3 ;
37887   int arg4 ;
37888   int arg5 ;
37889
37890   arg1 = (Dali::Layer *)jarg1;
37891   arg2 = (int)jarg2;
37892   arg3 = (int)jarg3;
37893   arg4 = (int)jarg4;
37894   arg5 = (int)jarg5;
37895   {
37896     try {
37897       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37898     } catch (std::out_of_range& e) {
37899       {
37900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (std::exception& e) {
37903       {
37904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (Dali::DaliException e) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916
37917 }
37918
37919
37920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37921   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37922   Dali::ClippingBox arg2 ;
37923   Dali::ClippingBox *argp2 ;
37924
37925   arg1 = (Dali::Layer *)jarg1;
37926   argp2 = (Dali::ClippingBox *)jarg2;
37927   if (!argp2) {
37928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37929     return ;
37930   }
37931   arg2 = *argp2;
37932   {
37933     try {
37934       (arg1)->SetClippingBox(arg2);
37935     } catch (std::out_of_range& e) {
37936       {
37937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37938       };
37939     } catch (std::exception& e) {
37940       {
37941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37942       };
37943     } catch (Dali::DaliException e) {
37944       {
37945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37946       };
37947     } catch (...) {
37948       {
37949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37950       };
37951     }
37952   }
37953
37954 }
37955
37956
37957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37958   void * jresult ;
37959   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37960   Dali::ClippingBox result;
37961
37962   arg1 = (Dali::Layer *)jarg1;
37963   {
37964     try {
37965       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37966     } catch (std::out_of_range& e) {
37967       {
37968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37969       };
37970     } catch (std::exception& e) {
37971       {
37972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37973       };
37974     } catch (Dali::DaliException e) {
37975       {
37976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37977       };
37978     } catch (...) {
37979       {
37980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37981       };
37982     }
37983   }
37984
37985   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37986   return jresult;
37987 }
37988
37989
37990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37991   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37992   bool arg2 ;
37993
37994   arg1 = (Dali::Layer *)jarg1;
37995   arg2 = jarg2 ? true : false;
37996   {
37997     try {
37998       (arg1)->SetDepthTestDisabled(arg2);
37999     } catch (std::out_of_range& e) {
38000       {
38001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38002       };
38003     } catch (std::exception& e) {
38004       {
38005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38006       };
38007     } catch (Dali::DaliException e) {
38008       {
38009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38014       };
38015     }
38016   }
38017
38018 }
38019
38020
38021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38022   unsigned int jresult ;
38023   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38024   bool result;
38025
38026   arg1 = (Dali::Layer *)jarg1;
38027   {
38028     try {
38029       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38037       };
38038     } catch (Dali::DaliException e) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38041       };
38042     } catch (...) {
38043       {
38044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38045       };
38046     }
38047   }
38048
38049   jresult = result;
38050   return jresult;
38051 }
38052
38053
38054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38055   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38056   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38057
38058   arg1 = (Dali::Layer *)jarg1;
38059   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38060   {
38061     try {
38062       (arg1)->SetSortFunction(arg2);
38063     } catch (std::out_of_range& e) {
38064       {
38065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38066       };
38067     } catch (std::exception& e) {
38068       {
38069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (Dali::DaliException e) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38074       };
38075     } catch (...) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38078       };
38079     }
38080   }
38081
38082 }
38083
38084
38085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38086   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38087   bool arg2 ;
38088
38089   arg1 = (Dali::Layer *)jarg1;
38090   arg2 = jarg2 ? true : false;
38091   {
38092     try {
38093       (arg1)->SetTouchConsumed(arg2);
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38101       };
38102     } catch (Dali::DaliException e) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38105       };
38106     } catch (...) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38109       };
38110     }
38111   }
38112
38113 }
38114
38115
38116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38117   unsigned int jresult ;
38118   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38119   bool result;
38120
38121   arg1 = (Dali::Layer *)jarg1;
38122   {
38123     try {
38124       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38125     } catch (std::out_of_range& e) {
38126       {
38127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38128       };
38129     } catch (std::exception& e) {
38130       {
38131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38132       };
38133     } catch (Dali::DaliException e) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38136       };
38137     } catch (...) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38140       };
38141     }
38142   }
38143
38144   jresult = result;
38145   return jresult;
38146 }
38147
38148
38149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38150   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38151   bool arg2 ;
38152
38153   arg1 = (Dali::Layer *)jarg1;
38154   arg2 = jarg2 ? true : false;
38155   {
38156     try {
38157       (arg1)->SetHoverConsumed(arg2);
38158     } catch (std::out_of_range& e) {
38159       {
38160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38161       };
38162     } catch (std::exception& e) {
38163       {
38164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38165       };
38166     } catch (Dali::DaliException e) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38169       };
38170     } catch (...) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38173       };
38174     }
38175   }
38176
38177 }
38178
38179
38180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38181   unsigned int jresult ;
38182   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38183   bool result;
38184
38185   arg1 = (Dali::Layer *)jarg1;
38186   {
38187     try {
38188       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38189     } catch (std::out_of_range& e) {
38190       {
38191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38192       };
38193     } catch (std::exception& e) {
38194       {
38195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38196       };
38197     } catch (Dali::DaliException e) {
38198       {
38199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38200       };
38201     } catch (...) {
38202       {
38203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38204       };
38205     }
38206   }
38207
38208   jresult = result;
38209   return jresult;
38210 }
38211
38212
38213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38214   void * jresult ;
38215   Dali::Vector4 *result = 0 ;
38216
38217   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38218   jresult = (void *)result;
38219   return jresult;
38220 }
38221
38222
38223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38224   void * jresult ;
38225   Dali::Vector4 *result = 0 ;
38226
38227   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38228   jresult = (void *)result;
38229   return jresult;
38230 }
38231
38232
38233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38234   void * jresult ;
38235   Dali::Stage *result = 0 ;
38236
38237   {
38238     try {
38239       result = (Dali::Stage *)new Dali::Stage();
38240     } catch (std::out_of_range& e) {
38241       {
38242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38243       };
38244     } catch (std::exception& e) {
38245       {
38246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38247       };
38248     } catch (Dali::DaliException e) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38251       };
38252     } catch (...) {
38253       {
38254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38255       };
38256     }
38257   }
38258
38259   jresult = (void *)result;
38260   return jresult;
38261 }
38262
38263
38264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38265   void * jresult ;
38266   Dali::Stage result;
38267
38268   {
38269     try {
38270       result = Dali::Stage::GetCurrent();
38271     } catch (std::out_of_range& e) {
38272       {
38273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38274       };
38275     } catch (std::exception& e) {
38276       {
38277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38278       };
38279     } catch (Dali::DaliException e) {
38280       {
38281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38282       };
38283     } catch (...) {
38284       {
38285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38286       };
38287     }
38288   }
38289
38290   jresult = new Dali::Stage((const Dali::Stage &)result);
38291   return jresult;
38292 }
38293
38294
38295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38296   unsigned int jresult ;
38297   bool result;
38298
38299   {
38300     try {
38301       result = (bool)Dali::Stage::IsInstalled();
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (Dali::DaliException e) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320
38321   jresult = result;
38322   return jresult;
38323 }
38324
38325
38326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38327   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38328
38329   arg1 = (Dali::Stage *)jarg1;
38330   {
38331     try {
38332       delete arg1;
38333     } catch (std::out_of_range& e) {
38334       {
38335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38336       };
38337     } catch (std::exception& e) {
38338       {
38339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38340       };
38341     } catch (Dali::DaliException e) {
38342       {
38343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38344       };
38345     } catch (...) {
38346       {
38347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38348       };
38349     }
38350   }
38351
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38356   void * jresult ;
38357   Dali::Stage *arg1 = 0 ;
38358   Dali::Stage *result = 0 ;
38359
38360   arg1 = (Dali::Stage *)jarg1;
38361   if (!arg1) {
38362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38363     return 0;
38364   }
38365   {
38366     try {
38367       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38368     } catch (std::out_of_range& e) {
38369       {
38370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (std::exception& e) {
38373       {
38374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (Dali::DaliException e) {
38377       {
38378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38379       };
38380     } catch (...) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38383       };
38384     }
38385   }
38386
38387   jresult = (void *)result;
38388   return jresult;
38389 }
38390
38391
38392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38393   void * jresult ;
38394   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38395   Dali::Stage *arg2 = 0 ;
38396   Dali::Stage *result = 0 ;
38397
38398   arg1 = (Dali::Stage *)jarg1;
38399   arg2 = (Dali::Stage *)jarg2;
38400   if (!arg2) {
38401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38402     return 0;
38403   }
38404   {
38405     try {
38406       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38407     } catch (std::out_of_range& e) {
38408       {
38409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38410       };
38411     } catch (std::exception& e) {
38412       {
38413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38414       };
38415     } catch (Dali::DaliException e) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38418       };
38419     } catch (...) {
38420       {
38421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38422       };
38423     }
38424   }
38425
38426   jresult = (void *)result;
38427   return jresult;
38428 }
38429
38430
38431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38432   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38433   Dali::Actor *arg2 = 0 ;
38434
38435   arg1 = (Dali::Stage *)jarg1;
38436   arg2 = (Dali::Actor *)jarg2;
38437   if (!arg2) {
38438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38439     return ;
38440   }
38441   {
38442     try {
38443       (arg1)->Add(*arg2);
38444     } catch (std::out_of_range& e) {
38445       {
38446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38447       };
38448     } catch (std::exception& e) {
38449       {
38450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38451       };
38452     } catch (Dali::DaliException e) {
38453       {
38454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38455       };
38456     } catch (...) {
38457       {
38458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38459       };
38460     }
38461   }
38462
38463 }
38464
38465
38466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38467   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38468   Dali::Actor *arg2 = 0 ;
38469
38470   arg1 = (Dali::Stage *)jarg1;
38471   arg2 = (Dali::Actor *)jarg2;
38472   if (!arg2) {
38473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38474     return ;
38475   }
38476   {
38477     try {
38478       (arg1)->Remove(*arg2);
38479     } catch (std::out_of_range& e) {
38480       {
38481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38482       };
38483     } catch (std::exception& e) {
38484       {
38485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38486       };
38487     } catch (Dali::DaliException e) {
38488       {
38489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38490       };
38491     } catch (...) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38494       };
38495     }
38496   }
38497
38498 }
38499
38500
38501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38502   void * jresult ;
38503   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38504   Dali::Vector2 result;
38505
38506   arg1 = (Dali::Stage *)jarg1;
38507   {
38508     try {
38509       result = ((Dali::Stage const *)arg1)->GetSize();
38510     } catch (std::out_of_range& e) {
38511       {
38512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (std::exception& e) {
38515       {
38516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38517       };
38518     } catch (Dali::DaliException e) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38521       };
38522     } catch (...) {
38523       {
38524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38525       };
38526     }
38527   }
38528
38529   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38530   return jresult;
38531 }
38532
38533
38534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38535   void * jresult ;
38536   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38537   Dali::RenderTaskList result;
38538
38539   arg1 = (Dali::Stage *)jarg1;
38540   {
38541     try {
38542       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38543     } catch (std::out_of_range& e) {
38544       {
38545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (std::exception& e) {
38548       {
38549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38550       };
38551     } catch (Dali::DaliException e) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38554       };
38555     } catch (...) {
38556       {
38557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38558       };
38559     }
38560   }
38561
38562   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38563   return jresult;
38564 }
38565
38566
38567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38568   unsigned int jresult ;
38569   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38570   unsigned int result;
38571
38572   arg1 = (Dali::Stage *)jarg1;
38573   {
38574     try {
38575       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38583       };
38584     } catch (Dali::DaliException e) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38587       };
38588     } catch (...) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38591       };
38592     }
38593   }
38594
38595   jresult = result;
38596   return jresult;
38597 }
38598
38599
38600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38601   void * jresult ;
38602   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38603   unsigned int arg2 ;
38604   Dali::Layer result;
38605
38606   arg1 = (Dali::Stage *)jarg1;
38607   arg2 = (unsigned int)jarg2;
38608   {
38609     try {
38610       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38611     } catch (std::out_of_range& e) {
38612       {
38613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38614       };
38615     } catch (std::exception& e) {
38616       {
38617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38618       };
38619     } catch (Dali::DaliException e) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38622       };
38623     } catch (...) {
38624       {
38625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38626       };
38627     }
38628   }
38629
38630   jresult = new Dali::Layer((const Dali::Layer &)result);
38631   return jresult;
38632 }
38633
38634
38635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38636   void * jresult ;
38637   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38638   Dali::Layer result;
38639
38640   arg1 = (Dali::Stage *)jarg1;
38641   {
38642     try {
38643       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38644     } catch (std::out_of_range& e) {
38645       {
38646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (std::exception& e) {
38649       {
38650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38651       };
38652     } catch (Dali::DaliException e) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38655       };
38656     } catch (...) {
38657       {
38658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38659       };
38660     }
38661   }
38662
38663   jresult = new Dali::Layer((const Dali::Layer &)result);
38664   return jresult;
38665 }
38666
38667
38668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38669   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38670   Dali::Vector4 arg2 ;
38671   Dali::Vector4 *argp2 ;
38672
38673   arg1 = (Dali::Stage *)jarg1;
38674   argp2 = (Dali::Vector4 *)jarg2;
38675   if (!argp2) {
38676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38677     return ;
38678   }
38679   arg2 = *argp2;
38680   {
38681     try {
38682       (arg1)->SetBackgroundColor(arg2);
38683     } catch (std::out_of_range& e) {
38684       {
38685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38686       };
38687     } catch (std::exception& e) {
38688       {
38689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38690       };
38691     } catch (Dali::DaliException e) {
38692       {
38693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38694       };
38695     } catch (...) {
38696       {
38697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38698       };
38699     }
38700   }
38701
38702 }
38703
38704
38705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38706   void * jresult ;
38707   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38708   Dali::Vector4 result;
38709
38710   arg1 = (Dali::Stage *)jarg1;
38711   {
38712     try {
38713       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38714     } catch (std::out_of_range& e) {
38715       {
38716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38717       };
38718     } catch (std::exception& e) {
38719       {
38720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38721       };
38722     } catch (Dali::DaliException e) {
38723       {
38724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38725       };
38726     } catch (...) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38729       };
38730     }
38731   }
38732
38733   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38734   return jresult;
38735 }
38736
38737
38738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38739   void * jresult ;
38740   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38741   Dali::Vector2 result;
38742
38743   arg1 = (Dali::Stage *)jarg1;
38744   {
38745     try {
38746       result = ((Dali::Stage const *)arg1)->GetDpi();
38747     } catch (std::out_of_range& e) {
38748       {
38749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (std::exception& e) {
38752       {
38753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (Dali::DaliException e) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38758       };
38759     } catch (...) {
38760       {
38761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38762       };
38763     }
38764   }
38765
38766   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38767   return jresult;
38768 }
38769
38770
38771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38772   void * jresult ;
38773   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38774   Dali::ObjectRegistry result;
38775
38776   arg1 = (Dali::Stage *)jarg1;
38777   {
38778     try {
38779       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38780     } catch (std::out_of_range& e) {
38781       {
38782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (std::exception& e) {
38785       {
38786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38787       };
38788     } catch (Dali::DaliException e) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38791       };
38792     } catch (...) {
38793       {
38794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38795       };
38796     }
38797   }
38798
38799   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38800   return jresult;
38801 }
38802
38803
38804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38805   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38806   float arg2 ;
38807
38808   arg1 = (Dali::Stage *)jarg1;
38809   arg2 = (float)jarg2;
38810   {
38811     try {
38812       (arg1)->KeepRendering(arg2);
38813     } catch (std::out_of_range& e) {
38814       {
38815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38816       };
38817     } catch (std::exception& e) {
38818       {
38819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38820       };
38821     } catch (Dali::DaliException e) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38824       };
38825     } catch (...) {
38826       {
38827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38828       };
38829     }
38830   }
38831
38832 }
38833
38834
38835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38836   void * jresult ;
38837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38838   Dali::Stage::KeyEventSignalType *result = 0 ;
38839
38840   arg1 = (Dali::Stage *)jarg1;
38841   {
38842     try {
38843       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38844     } catch (std::out_of_range& e) {
38845       {
38846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (std::exception& e) {
38849       {
38850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38851       };
38852     } catch (Dali::DaliException e) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38855       };
38856     } catch (...) {
38857       {
38858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38859       };
38860     }
38861   }
38862
38863   jresult = (void *)result;
38864   return jresult;
38865 }
38866
38867
38868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38869   void * jresult ;
38870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38871   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38872
38873   arg1 = (Dali::Stage *)jarg1;
38874   {
38875     try {
38876       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38877     } catch (std::out_of_range& e) {
38878       {
38879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (std::exception& e) {
38882       {
38883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38884       };
38885     } catch (Dali::DaliException e) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38888       };
38889     } catch (...) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38892       };
38893     }
38894   }
38895
38896   jresult = (void *)result;
38897   return jresult;
38898 }
38899
38900
38901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38902   void * jresult ;
38903   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38904   Dali::Stage::TouchSignalType *result = 0 ;
38905
38906   arg1 = (Dali::Stage *)jarg1;
38907   {
38908     try {
38909       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38917       };
38918     } catch (Dali::DaliException e) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38921       };
38922     } catch (...) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38925       };
38926     }
38927   }
38928
38929   jresult = (void *)result;
38930   return jresult;
38931 }
38932
38933
38934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38935   void * jresult ;
38936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38937   Dali::Stage::WheelEventSignalType *result = 0 ;
38938
38939   arg1 = (Dali::Stage *)jarg1;
38940   {
38941     try {
38942       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38943     } catch (std::out_of_range& e) {
38944       {
38945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (std::exception& e) {
38948       {
38949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38950       };
38951     } catch (Dali::DaliException e) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38954       };
38955     } catch (...) {
38956       {
38957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38958       };
38959     }
38960   }
38961
38962   jresult = (void *)result;
38963   return jresult;
38964 }
38965
38966
38967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38968   void * jresult ;
38969   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38970   Dali::Stage::ContextStatusSignal *result = 0 ;
38971
38972   arg1 = (Dali::Stage *)jarg1;
38973   {
38974     try {
38975       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (Dali::DaliException e) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38987       };
38988     } catch (...) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38991       };
38992     }
38993   }
38994
38995   jresult = (void *)result;
38996   return jresult;
38997 }
38998
38999
39000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39001   void * jresult ;
39002   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39003   Dali::Stage::ContextStatusSignal *result = 0 ;
39004
39005   arg1 = (Dali::Stage *)jarg1;
39006   {
39007     try {
39008       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (Dali::DaliException e) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39020       };
39021     } catch (...) {
39022       {
39023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39024       };
39025     }
39026   }
39027
39028   jresult = (void *)result;
39029   return jresult;
39030 }
39031
39032
39033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39034   void * jresult ;
39035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39036   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39037
39038   arg1 = (Dali::Stage *)jarg1;
39039   {
39040     try {
39041       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (Dali::DaliException e) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39053       };
39054     } catch (...) {
39055       {
39056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39057       };
39058     }
39059   }
39060
39061   jresult = (void *)result;
39062   return jresult;
39063 }
39064
39065
39066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39067   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39068
39069   arg1 = (Dali::RelayoutContainer *)jarg1;
39070   {
39071     try {
39072       delete arg1;
39073     } catch (std::out_of_range& e) {
39074       {
39075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39076       };
39077     } catch (std::exception& e) {
39078       {
39079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39080       };
39081     } catch (Dali::DaliException e) {
39082       {
39083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39084       };
39085     } catch (...) {
39086       {
39087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39088       };
39089     }
39090   }
39091
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39096   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39097   Dali::Actor *arg2 = 0 ;
39098   Dali::Vector2 *arg3 = 0 ;
39099
39100   arg1 = (Dali::RelayoutContainer *)jarg1;
39101   arg2 = (Dali::Actor *)jarg2;
39102   if (!arg2) {
39103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39104     return ;
39105   }
39106   arg3 = (Dali::Vector2 *)jarg3;
39107   if (!arg3) {
39108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39109     return ;
39110   }
39111   {
39112     try {
39113       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39114     } catch (std::out_of_range& e) {
39115       {
39116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39117       };
39118     } catch (std::exception& e) {
39119       {
39120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39121       };
39122     } catch (Dali::DaliException e) {
39123       {
39124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39125       };
39126     } catch (...) {
39127       {
39128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39129       };
39130     }
39131   }
39132
39133 }
39134
39135
39136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39137   void * jresult ;
39138   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39139   Dali::CustomActor result;
39140
39141   arg1 = (Dali::CustomActorImpl *)jarg1;
39142   {
39143     try {
39144       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39145     } catch (std::out_of_range& e) {
39146       {
39147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39148       };
39149     } catch (std::exception& e) {
39150       {
39151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39152       };
39153     } catch (Dali::DaliException e) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39156       };
39157     } catch (...) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39160       };
39161     }
39162   }
39163
39164   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39165   return jresult;
39166 }
39167
39168
39169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39170   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39171   int arg2 ;
39172
39173   arg1 = (Dali::CustomActorImpl *)jarg1;
39174   arg2 = (int)jarg2;
39175   {
39176     try {
39177       (arg1)->OnStageConnection(arg2);
39178     } catch (std::out_of_range& e) {
39179       {
39180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39181       };
39182     } catch (std::exception& e) {
39183       {
39184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39185       };
39186     } catch (Dali::DaliException e) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39189       };
39190     } catch (...) {
39191       {
39192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39193       };
39194     }
39195   }
39196
39197 }
39198
39199
39200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39201   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39202
39203   arg1 = (Dali::CustomActorImpl *)jarg1;
39204   {
39205     try {
39206       (arg1)->OnStageDisconnection();
39207     } catch (std::out_of_range& e) {
39208       {
39209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (std::exception& e) {
39212       {
39213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39214       };
39215     } catch (Dali::DaliException e) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39218       };
39219     } catch (...) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39222       };
39223     }
39224   }
39225
39226 }
39227
39228
39229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39231   Dali::Actor *arg2 = 0 ;
39232
39233   arg1 = (Dali::CustomActorImpl *)jarg1;
39234   arg2 = (Dali::Actor *)jarg2;
39235   if (!arg2) {
39236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39237     return ;
39238   }
39239   {
39240     try {
39241       (arg1)->OnChildAdd(*arg2);
39242     } catch (std::out_of_range& e) {
39243       {
39244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39245       };
39246     } catch (std::exception& e) {
39247       {
39248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39249       };
39250     } catch (Dali::DaliException e) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39253       };
39254     } catch (...) {
39255       {
39256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39257       };
39258     }
39259   }
39260
39261 }
39262
39263
39264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39265   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39266   Dali::Actor *arg2 = 0 ;
39267
39268   arg1 = (Dali::CustomActorImpl *)jarg1;
39269   arg2 = (Dali::Actor *)jarg2;
39270   if (!arg2) {
39271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39272     return ;
39273   }
39274   {
39275     try {
39276       (arg1)->OnChildRemove(*arg2);
39277     } catch (std::out_of_range& e) {
39278       {
39279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39280       };
39281     } catch (std::exception& e) {
39282       {
39283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39284       };
39285     } catch (Dali::DaliException e) {
39286       {
39287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39288       };
39289     } catch (...) {
39290       {
39291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39292       };
39293     }
39294   }
39295
39296 }
39297
39298
39299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39300   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39301   Dali::Property::Index arg2 ;
39302   Dali::Property::Value arg3 ;
39303   Dali::Property::Value *argp3 ;
39304
39305   arg1 = (Dali::CustomActorImpl *)jarg1;
39306   arg2 = (Dali::Property::Index)jarg2;
39307   argp3 = (Dali::Property::Value *)jarg3;
39308   if (!argp3) {
39309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39310     return ;
39311   }
39312   arg3 = *argp3;
39313   {
39314     try {
39315       (arg1)->OnPropertySet(arg2,arg3);
39316     } catch (std::out_of_range& e) {
39317       {
39318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39319       };
39320     } catch (std::exception& e) {
39321       {
39322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39323       };
39324     } catch (Dali::DaliException e) {
39325       {
39326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39327       };
39328     } catch (...) {
39329       {
39330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39331       };
39332     }
39333   }
39334
39335 }
39336
39337
39338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39339   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39340   Dali::Vector3 *arg2 = 0 ;
39341
39342   arg1 = (Dali::CustomActorImpl *)jarg1;
39343   arg2 = (Dali::Vector3 *)jarg2;
39344   if (!arg2) {
39345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39346     return ;
39347   }
39348   {
39349     try {
39350       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39351     } catch (std::out_of_range& e) {
39352       {
39353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39354       };
39355     } catch (std::exception& e) {
39356       {
39357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39358       };
39359     } catch (Dali::DaliException e) {
39360       {
39361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39362       };
39363     } catch (...) {
39364       {
39365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39366       };
39367     }
39368   }
39369
39370 }
39371
39372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39374   Dali::Animation *arg2 = 0 ;
39375   Dali::Vector3 *arg3 = 0 ;
39376
39377   arg1 = (Dali::CustomActorImpl *)jarg1;
39378   arg2 = (Dali::Animation *)jarg2;
39379   if (!arg2) {
39380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39381     return ;
39382   }
39383   arg3 = (Dali::Vector3 *)jarg3;
39384   if (!arg3) {
39385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39386     return ;
39387   }
39388   {
39389     try {
39390       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39391     } catch (std::out_of_range& e) {
39392       {
39393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39394       };
39395     } catch (std::exception& e) {
39396       {
39397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39398       };
39399     } catch (Dali::DaliException e) {
39400       {
39401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39402       };
39403     } catch (...) {
39404       {
39405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39406       };
39407     }
39408   }
39409
39410 }
39411
39412
39413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39414   unsigned int jresult ;
39415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39416   Dali::TouchEvent *arg2 = 0 ;
39417   bool result;
39418
39419   arg1 = (Dali::CustomActorImpl *)jarg1;
39420   arg2 = (Dali::TouchEvent *)jarg2;
39421   if (!arg2) {
39422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39423     return 0;
39424   }
39425   {
39426     try {
39427       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39428     } catch (std::out_of_range& e) {
39429       {
39430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39431       };
39432     } catch (std::exception& e) {
39433       {
39434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39435       };
39436     } catch (Dali::DaliException e) {
39437       {
39438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39439       };
39440     } catch (...) {
39441       {
39442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39443       };
39444     }
39445   }
39446
39447   jresult = result;
39448   return jresult;
39449 }
39450
39451
39452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39453   unsigned int jresult ;
39454   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39455   Dali::HoverEvent *arg2 = 0 ;
39456   bool result;
39457
39458   arg1 = (Dali::CustomActorImpl *)jarg1;
39459   arg2 = (Dali::HoverEvent *)jarg2;
39460   if (!arg2) {
39461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39462     return 0;
39463   }
39464   {
39465     try {
39466       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39467     } catch (std::out_of_range& e) {
39468       {
39469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39470       };
39471     } catch (std::exception& e) {
39472       {
39473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39474       };
39475     } catch (Dali::DaliException e) {
39476       {
39477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39478       };
39479     } catch (...) {
39480       {
39481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39482       };
39483     }
39484   }
39485
39486   jresult = result;
39487   return jresult;
39488 }
39489
39490
39491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39492   unsigned int jresult ;
39493   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39494   Dali::KeyEvent *arg2 = 0 ;
39495   bool result;
39496
39497   arg1 = (Dali::CustomActorImpl *)jarg1;
39498   arg2 = (Dali::KeyEvent *)jarg2;
39499   if (!arg2) {
39500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39501     return 0;
39502   }
39503   {
39504     try {
39505       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39521       };
39522     }
39523   }
39524
39525   jresult = result;
39526   return jresult;
39527 }
39528
39529
39530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39531   unsigned int jresult ;
39532   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39533   Dali::WheelEvent *arg2 = 0 ;
39534   bool result;
39535
39536   arg1 = (Dali::CustomActorImpl *)jarg1;
39537   arg2 = (Dali::WheelEvent *)jarg2;
39538   if (!arg2) {
39539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39540     return 0;
39541   }
39542   {
39543     try {
39544       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39552       };
39553     } catch (Dali::DaliException e) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39556       };
39557     } catch (...) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39560       };
39561     }
39562   }
39563
39564   jresult = result;
39565   return jresult;
39566 }
39567
39568
39569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39571   Dali::Vector2 *arg2 = 0 ;
39572   Dali::RelayoutContainer *arg3 = 0 ;
39573
39574   arg1 = (Dali::CustomActorImpl *)jarg1;
39575   arg2 = (Dali::Vector2 *)jarg2;
39576   if (!arg2) {
39577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39578     return ;
39579   }
39580   arg3 = (Dali::RelayoutContainer *)jarg3;
39581   if (!arg3) {
39582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39583     return ;
39584   }
39585   {
39586     try {
39587       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39595       };
39596     } catch (Dali::DaliException e) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39603       };
39604     }
39605   }
39606
39607 }
39608
39609
39610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39611   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39612   Dali::ResizePolicy::Type arg2 ;
39613   Dali::Dimension::Type arg3 ;
39614
39615   arg1 = (Dali::CustomActorImpl *)jarg1;
39616   arg2 = (Dali::ResizePolicy::Type)jarg2;
39617   arg3 = (Dali::Dimension::Type)jarg3;
39618   {
39619     try {
39620       (arg1)->OnSetResizePolicy(arg2,arg3);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39636       };
39637     }
39638   }
39639
39640 }
39641
39642
39643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39644   void * jresult ;
39645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39646   Dali::Vector3 result;
39647
39648   arg1 = (Dali::CustomActorImpl *)jarg1;
39649   {
39650     try {
39651       result = (arg1)->GetNaturalSize();
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39667       };
39668     }
39669   }
39670
39671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39672   return jresult;
39673 }
39674
39675
39676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39677   float jresult ;
39678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39679   Dali::Actor *arg2 = 0 ;
39680   Dali::Dimension::Type arg3 ;
39681   float result;
39682
39683   arg1 = (Dali::CustomActorImpl *)jarg1;
39684   arg2 = (Dali::Actor *)jarg2;
39685   if (!arg2) {
39686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39687     return 0;
39688   }
39689   arg3 = (Dali::Dimension::Type)jarg3;
39690   {
39691     try {
39692       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39693     } catch (std::out_of_range& e) {
39694       {
39695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39696       };
39697     } catch (std::exception& e) {
39698       {
39699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39700       };
39701     } catch (Dali::DaliException e) {
39702       {
39703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39704       };
39705     } catch (...) {
39706       {
39707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39708       };
39709     }
39710   }
39711
39712   jresult = result;
39713   return jresult;
39714 }
39715
39716
39717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39718   float jresult ;
39719   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39720   float arg2 ;
39721   float result;
39722
39723   arg1 = (Dali::CustomActorImpl *)jarg1;
39724   arg2 = (float)jarg2;
39725   {
39726     try {
39727       result = (float)(arg1)->GetHeightForWidth(arg2);
39728     } catch (std::out_of_range& e) {
39729       {
39730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39731       };
39732     } catch (std::exception& e) {
39733       {
39734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39735       };
39736     } catch (Dali::DaliException e) {
39737       {
39738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39739       };
39740     } catch (...) {
39741       {
39742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39743       };
39744     }
39745   }
39746
39747   jresult = result;
39748   return jresult;
39749 }
39750
39751
39752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39753   float jresult ;
39754   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39755   float arg2 ;
39756   float result;
39757
39758   arg1 = (Dali::CustomActorImpl *)jarg1;
39759   arg2 = (float)jarg2;
39760   {
39761     try {
39762       result = (float)(arg1)->GetWidthForHeight(arg2);
39763     } catch (std::out_of_range& e) {
39764       {
39765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39766       };
39767     } catch (std::exception& e) {
39768       {
39769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (Dali::DaliException e) {
39772       {
39773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39774       };
39775     } catch (...) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39778       };
39779     }
39780   }
39781
39782   jresult = result;
39783   return jresult;
39784 }
39785
39786
39787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39788   unsigned int jresult ;
39789   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39790   Dali::Dimension::Type arg2 ;
39791   bool result;
39792
39793   arg1 = (Dali::CustomActorImpl *)jarg1;
39794   arg2 = (Dali::Dimension::Type)jarg2;
39795   {
39796     try {
39797       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39798     } catch (std::out_of_range& e) {
39799       {
39800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39801       };
39802     } catch (std::exception& e) {
39803       {
39804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39805       };
39806     } catch (Dali::DaliException e) {
39807       {
39808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39809       };
39810     } catch (...) {
39811       {
39812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39813       };
39814     }
39815   }
39816
39817   jresult = result;
39818   return jresult;
39819 }
39820
39821
39822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39823   unsigned int jresult ;
39824   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39825   bool result;
39826
39827   arg1 = (Dali::CustomActorImpl *)jarg1;
39828   {
39829     try {
39830       result = (bool)(arg1)->RelayoutDependentOnChildren();
39831     } catch (std::out_of_range& e) {
39832       {
39833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (std::exception& e) {
39836       {
39837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (Dali::DaliException e) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39842       };
39843     } catch (...) {
39844       {
39845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39846       };
39847     }
39848   }
39849
39850   jresult = result;
39851   return jresult;
39852 }
39853
39854
39855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39856   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39857   Dali::Dimension::Type arg2 ;
39858
39859   arg1 = (Dali::CustomActorImpl *)jarg1;
39860   arg2 = (Dali::Dimension::Type)jarg2;
39861   {
39862     try {
39863       (arg1)->OnCalculateRelayoutSize(arg2);
39864     } catch (std::out_of_range& e) {
39865       {
39866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39867       };
39868     } catch (std::exception& e) {
39869       {
39870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39871       };
39872     } catch (Dali::DaliException e) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39875       };
39876     } catch (...) {
39877       {
39878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39879       };
39880     }
39881   }
39882
39883 }
39884
39885
39886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39887   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39888   float arg2 ;
39889   Dali::Dimension::Type arg3 ;
39890
39891   arg1 = (Dali::CustomActorImpl *)jarg1;
39892   arg2 = (float)jarg2;
39893   arg3 = (Dali::Dimension::Type)jarg3;
39894   {
39895     try {
39896       (arg1)->OnLayoutNegotiated(arg2,arg3);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (Dali::DaliException e) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39908       };
39909     } catch (...) {
39910       {
39911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39912       };
39913     }
39914   }
39915
39916 }
39917
39918
39919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39920   unsigned int jresult ;
39921   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39922   bool result;
39923
39924   arg1 = (Dali::CustomActorImpl *)jarg1;
39925   {
39926     try {
39927       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39928     } catch (std::out_of_range& e) {
39929       {
39930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39931       };
39932     } catch (std::exception& e) {
39933       {
39934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39935       };
39936     } catch (Dali::DaliException e) {
39937       {
39938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39939       };
39940     } catch (...) {
39941       {
39942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39943       };
39944     }
39945   }
39946
39947   jresult = result;
39948   return jresult;
39949 }
39950
39951
39952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39953   unsigned int jresult ;
39954   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39955   bool result;
39956
39957   arg1 = (Dali::CustomActorImpl *)jarg1;
39958   {
39959     try {
39960       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39961     } catch (std::out_of_range& e) {
39962       {
39963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (std::exception& e) {
39966       {
39967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (Dali::DaliException e) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39972       };
39973     } catch (...) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39976       };
39977     }
39978   }
39979
39980   jresult = result;
39981   return jresult;
39982 }
39983
39984
39985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39986   unsigned int jresult ;
39987   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39988   bool result;
39989
39990   arg1 = (Dali::CustomActorImpl *)jarg1;
39991   {
39992     try {
39993       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39994     } catch (std::out_of_range& e) {
39995       {
39996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (std::exception& e) {
39999       {
40000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40001       };
40002     } catch (Dali::DaliException e) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40009       };
40010     }
40011   }
40012
40013   jresult = result;
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40019   unsigned int jresult ;
40020   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40021   bool result;
40022
40023   arg1 = (Dali::CustomActorImpl *)jarg1;
40024   {
40025     try {
40026       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40027     } catch (std::out_of_range& e) {
40028       {
40029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (std::exception& e) {
40032       {
40033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40034       };
40035     } catch (Dali::DaliException e) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40042       };
40043     }
40044   }
40045
40046   jresult = result;
40047   return jresult;
40048 }
40049
40050
40051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40052   void * jresult ;
40053   Dali::CustomActor *result = 0 ;
40054
40055   {
40056     try {
40057       result = (Dali::CustomActor *)new Dali::CustomActor();
40058     } catch (std::out_of_range& e) {
40059       {
40060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40061       };
40062     } catch (std::exception& e) {
40063       {
40064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40065       };
40066     } catch (Dali::DaliException e) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40069       };
40070     } catch (...) {
40071       {
40072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40073       };
40074     }
40075   }
40076
40077   jresult = (void *)result;
40078   return jresult;
40079 }
40080
40081
40082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40083   void * jresult ;
40084   Dali::BaseHandle arg1 ;
40085   Dali::BaseHandle *argp1 ;
40086   Dali::CustomActor result;
40087
40088   argp1 = (Dali::BaseHandle *)jarg1;
40089   if (!argp1) {
40090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40091     return 0;
40092   }
40093   arg1 = *argp1;
40094   {
40095     try {
40096       result = Dali::CustomActor::DownCast(arg1);
40097     } catch (std::out_of_range& e) {
40098       {
40099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40100       };
40101     } catch (std::exception& e) {
40102       {
40103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40104       };
40105     } catch (Dali::DaliException e) {
40106       {
40107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40108       };
40109     } catch (...) {
40110       {
40111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40112       };
40113     }
40114   }
40115
40116   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40117   return jresult;
40118 }
40119
40120
40121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40122   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40123
40124   arg1 = (Dali::CustomActor *)jarg1;
40125   {
40126     try {
40127       delete arg1;
40128     } catch (std::out_of_range& e) {
40129       {
40130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40131       };
40132     } catch (std::exception& e) {
40133       {
40134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40135       };
40136     } catch (Dali::DaliException e) {
40137       {
40138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40139       };
40140     } catch (...) {
40141       {
40142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40143       };
40144     }
40145   }
40146
40147 }
40148
40149
40150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40151   void * jresult ;
40152   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40153   Dali::CustomActorImpl *result = 0 ;
40154
40155   arg1 = (Dali::CustomActor *)jarg1;
40156   {
40157     try {
40158       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40159     } catch (std::out_of_range& e) {
40160       {
40161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40162       };
40163     } catch (std::exception& e) {
40164       {
40165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40166       };
40167     } catch (Dali::DaliException e) {
40168       {
40169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40170       };
40171     } catch (...) {
40172       {
40173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40174       };
40175     }
40176   }
40177
40178   jresult = (void *)result;
40179   return jresult;
40180 }
40181
40182
40183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40184   void * jresult ;
40185   Dali::CustomActorImpl *arg1 = 0 ;
40186   Dali::CustomActor *result = 0 ;
40187
40188   arg1 = (Dali::CustomActorImpl *)jarg1;
40189   if (!arg1) {
40190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40191     return 0;
40192   }
40193   {
40194     try {
40195       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40196     } catch (std::out_of_range& e) {
40197       {
40198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40199       };
40200     } catch (std::exception& e) {
40201       {
40202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40203       };
40204     } catch (Dali::DaliException e) {
40205       {
40206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40207       };
40208     } catch (...) {
40209       {
40210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40211       };
40212     }
40213   }
40214
40215   jresult = (void *)result;
40216   return jresult;
40217 }
40218
40219
40220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40221   void * jresult ;
40222   Dali::CustomActor *arg1 = 0 ;
40223   Dali::CustomActor *result = 0 ;
40224
40225   arg1 = (Dali::CustomActor *)jarg1;
40226   if (!arg1) {
40227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40228     return 0;
40229   }
40230   {
40231     try {
40232       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40233     } catch (std::out_of_range& e) {
40234       {
40235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40236       };
40237     } catch (std::exception& e) {
40238       {
40239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40240       };
40241     } catch (Dali::DaliException e) {
40242       {
40243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40244       };
40245     } catch (...) {
40246       {
40247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40248       };
40249     }
40250   }
40251
40252   jresult = (void *)result;
40253   return jresult;
40254 }
40255
40256
40257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40258   void * jresult ;
40259   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40260   Dali::CustomActor *arg2 = 0 ;
40261   Dali::CustomActor *result = 0 ;
40262
40263   arg1 = (Dali::CustomActor *)jarg1;
40264   arg2 = (Dali::CustomActor *)jarg2;
40265   if (!arg2) {
40266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40267     return 0;
40268   }
40269   {
40270     try {
40271       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40272     } catch (std::out_of_range& e) {
40273       {
40274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40275       };
40276     } catch (std::exception& e) {
40277       {
40278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40279       };
40280     } catch (Dali::DaliException e) {
40281       {
40282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40283       };
40284     } catch (...) {
40285       {
40286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40287       };
40288     }
40289   }
40290
40291   jresult = (void *)result;
40292   return jresult;
40293 }
40294
40295
40296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40297   int jresult ;
40298   int result;
40299
40300   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40301   jresult = (int)result;
40302   return jresult;
40303 }
40304
40305
40306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40307   int jresult ;
40308   int result;
40309
40310   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40311   jresult = (int)result;
40312   return jresult;
40313 }
40314
40315
40316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40317   int jresult ;
40318   int result;
40319
40320   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40321   jresult = (int)result;
40322   return jresult;
40323 }
40324
40325
40326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40327   int jresult ;
40328   int result;
40329
40330   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40331   jresult = (int)result;
40332   return jresult;
40333 }
40334
40335
40336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40337   int jresult ;
40338   int result;
40339
40340   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40341   jresult = (int)result;
40342   return jresult;
40343 }
40344
40345
40346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40347   int jresult ;
40348   int result;
40349
40350   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40351   jresult = (int)result;
40352   return jresult;
40353 }
40354
40355
40356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40357   int jresult ;
40358   int result;
40359
40360   result = (int)Dali::PanGestureDetector::Property::PANNING;
40361   jresult = (int)result;
40362   return jresult;
40363 }
40364
40365
40366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40367   void * jresult ;
40368   Dali::PanGestureDetector::Property *result = 0 ;
40369
40370   {
40371     try {
40372       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40373     } catch (std::out_of_range& e) {
40374       {
40375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40376       };
40377     } catch (std::exception& e) {
40378       {
40379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40380       };
40381     } catch (Dali::DaliException e) {
40382       {
40383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40384       };
40385     } catch (...) {
40386       {
40387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40388       };
40389     }
40390   }
40391
40392   jresult = (void *)result;
40393   return jresult;
40394 }
40395
40396
40397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40398   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40399
40400   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40401   {
40402     try {
40403       delete arg1;
40404     } catch (std::out_of_range& e) {
40405       {
40406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40407       };
40408     } catch (std::exception& e) {
40409       {
40410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40411       };
40412     } catch (Dali::DaliException e) {
40413       {
40414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40415       };
40416     } catch (...) {
40417       {
40418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40419       };
40420     }
40421   }
40422
40423 }
40424
40425
40426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40427   void * jresult ;
40428   Dali::Radian *result = 0 ;
40429
40430   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40431   jresult = (void *)result;
40432   return jresult;
40433 }
40434
40435
40436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40437   void * jresult ;
40438   Dali::Radian *result = 0 ;
40439
40440   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40441   jresult = (void *)result;
40442   return jresult;
40443 }
40444
40445
40446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40447   void * jresult ;
40448   Dali::Radian *result = 0 ;
40449
40450   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40451   jresult = (void *)result;
40452   return jresult;
40453 }
40454
40455
40456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40457   void * jresult ;
40458   Dali::Radian *result = 0 ;
40459
40460   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40461   jresult = (void *)result;
40462   return jresult;
40463 }
40464
40465
40466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40467   void * jresult ;
40468   Dali::Radian *result = 0 ;
40469
40470   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40471   jresult = (void *)result;
40472   return jresult;
40473 }
40474
40475
40476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40477   void * jresult ;
40478   Dali::Radian *result = 0 ;
40479
40480   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40481   jresult = (void *)result;
40482   return jresult;
40483 }
40484
40485
40486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40487   void * jresult ;
40488   Dali::Radian *result = 0 ;
40489
40490   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40491   jresult = (void *)result;
40492   return jresult;
40493 }
40494
40495
40496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40497   void * jresult ;
40498   Dali::PanGestureDetector *result = 0 ;
40499
40500   {
40501     try {
40502       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40503     } catch (std::out_of_range& e) {
40504       {
40505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40506       };
40507     } catch (std::exception& e) {
40508       {
40509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40510       };
40511     } catch (Dali::DaliException e) {
40512       {
40513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40514       };
40515     } catch (...) {
40516       {
40517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40518       };
40519     }
40520   }
40521
40522   jresult = (void *)result;
40523   return jresult;
40524 }
40525
40526
40527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40528   void * jresult ;
40529   Dali::PanGestureDetector result;
40530
40531   {
40532     try {
40533       result = Dali::PanGestureDetector::New();
40534     } catch (std::out_of_range& e) {
40535       {
40536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (std::exception& e) {
40539       {
40540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40541       };
40542     } catch (Dali::DaliException e) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40545       };
40546     } catch (...) {
40547       {
40548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40549       };
40550     }
40551   }
40552
40553   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40554   return jresult;
40555 }
40556
40557
40558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40559   void * jresult ;
40560   Dali::BaseHandle arg1 ;
40561   Dali::BaseHandle *argp1 ;
40562   Dali::PanGestureDetector result;
40563
40564   argp1 = (Dali::BaseHandle *)jarg1;
40565   if (!argp1) {
40566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40567     return 0;
40568   }
40569   arg1 = *argp1;
40570   {
40571     try {
40572       result = Dali::PanGestureDetector::DownCast(arg1);
40573     } catch (std::out_of_range& e) {
40574       {
40575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40576       };
40577     } catch (std::exception& e) {
40578       {
40579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40580       };
40581     } catch (Dali::DaliException e) {
40582       {
40583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40584       };
40585     } catch (...) {
40586       {
40587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40588       };
40589     }
40590   }
40591
40592   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40598   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40599
40600   arg1 = (Dali::PanGestureDetector *)jarg1;
40601   {
40602     try {
40603       delete arg1;
40604     } catch (std::out_of_range& e) {
40605       {
40606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40607       };
40608     } catch (std::exception& e) {
40609       {
40610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40611       };
40612     } catch (Dali::DaliException e) {
40613       {
40614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40615       };
40616     } catch (...) {
40617       {
40618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40619       };
40620     }
40621   }
40622
40623 }
40624
40625
40626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40627   void * jresult ;
40628   Dali::PanGestureDetector *arg1 = 0 ;
40629   Dali::PanGestureDetector *result = 0 ;
40630
40631   arg1 = (Dali::PanGestureDetector *)jarg1;
40632   if (!arg1) {
40633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40634     return 0;
40635   }
40636   {
40637     try {
40638       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40639     } catch (std::out_of_range& e) {
40640       {
40641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40642       };
40643     } catch (std::exception& e) {
40644       {
40645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40646       };
40647     } catch (Dali::DaliException e) {
40648       {
40649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40650       };
40651     } catch (...) {
40652       {
40653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40654       };
40655     }
40656   }
40657
40658   jresult = (void *)result;
40659   return jresult;
40660 }
40661
40662
40663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40664   void * jresult ;
40665   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40666   Dali::PanGestureDetector *arg2 = 0 ;
40667   Dali::PanGestureDetector *result = 0 ;
40668
40669   arg1 = (Dali::PanGestureDetector *)jarg1;
40670   arg2 = (Dali::PanGestureDetector *)jarg2;
40671   if (!arg2) {
40672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40673     return 0;
40674   }
40675   {
40676     try {
40677       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40678     } catch (std::out_of_range& e) {
40679       {
40680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40681       };
40682     } catch (std::exception& e) {
40683       {
40684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40685       };
40686     } catch (Dali::DaliException e) {
40687       {
40688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40689       };
40690     } catch (...) {
40691       {
40692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40693       };
40694     }
40695   }
40696
40697   jresult = (void *)result;
40698   return jresult;
40699 }
40700
40701
40702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40703   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40704   unsigned int arg2 ;
40705
40706   arg1 = (Dali::PanGestureDetector *)jarg1;
40707   arg2 = (unsigned int)jarg2;
40708   {
40709     try {
40710       (arg1)->SetMinimumTouchesRequired(arg2);
40711     } catch (std::out_of_range& e) {
40712       {
40713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40714       };
40715     } catch (std::exception& e) {
40716       {
40717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40718       };
40719     } catch (Dali::DaliException e) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40722       };
40723     } catch (...) {
40724       {
40725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40726       };
40727     }
40728   }
40729
40730 }
40731
40732
40733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40734   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40735   unsigned int arg2 ;
40736
40737   arg1 = (Dali::PanGestureDetector *)jarg1;
40738   arg2 = (unsigned int)jarg2;
40739   {
40740     try {
40741       (arg1)->SetMaximumTouchesRequired(arg2);
40742     } catch (std::out_of_range& e) {
40743       {
40744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40745       };
40746     } catch (std::exception& e) {
40747       {
40748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40749       };
40750     } catch (Dali::DaliException e) {
40751       {
40752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40753       };
40754     } catch (...) {
40755       {
40756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40757       };
40758     }
40759   }
40760
40761 }
40762
40763
40764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40765   unsigned int jresult ;
40766   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40767   unsigned int result;
40768
40769   arg1 = (Dali::PanGestureDetector *)jarg1;
40770   {
40771     try {
40772       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40773     } catch (std::out_of_range& e) {
40774       {
40775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (std::exception& e) {
40778       {
40779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40780       };
40781     } catch (Dali::DaliException e) {
40782       {
40783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40784       };
40785     } catch (...) {
40786       {
40787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40788       };
40789     }
40790   }
40791
40792   jresult = result;
40793   return jresult;
40794 }
40795
40796
40797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40798   unsigned int jresult ;
40799   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40800   unsigned int result;
40801
40802   arg1 = (Dali::PanGestureDetector *)jarg1;
40803   {
40804     try {
40805       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40806     } catch (std::out_of_range& e) {
40807       {
40808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (std::exception& e) {
40811       {
40812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40813       };
40814     } catch (Dali::DaliException e) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40817       };
40818     } catch (...) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40821       };
40822     }
40823   }
40824
40825   jresult = result;
40826   return jresult;
40827 }
40828
40829
40830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40831   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40832   Dali::Radian arg2 ;
40833   Dali::Radian arg3 ;
40834   Dali::Radian *argp2 ;
40835   Dali::Radian *argp3 ;
40836
40837   arg1 = (Dali::PanGestureDetector *)jarg1;
40838   argp2 = (Dali::Radian *)jarg2;
40839   if (!argp2) {
40840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40841     return ;
40842   }
40843   arg2 = *argp2;
40844   argp3 = (Dali::Radian *)jarg3;
40845   if (!argp3) {
40846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40847     return ;
40848   }
40849   arg3 = *argp3;
40850   {
40851     try {
40852       (arg1)->AddAngle(arg2,arg3);
40853     } catch (std::out_of_range& e) {
40854       {
40855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40856       };
40857     } catch (std::exception& e) {
40858       {
40859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40860       };
40861     } catch (Dali::DaliException e) {
40862       {
40863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40864       };
40865     } catch (...) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40868       };
40869     }
40870   }
40871
40872 }
40873
40874
40875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40876   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40877   Dali::Radian arg2 ;
40878   Dali::Radian *argp2 ;
40879
40880   arg1 = (Dali::PanGestureDetector *)jarg1;
40881   argp2 = (Dali::Radian *)jarg2;
40882   if (!argp2) {
40883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40884     return ;
40885   }
40886   arg2 = *argp2;
40887   {
40888     try {
40889       (arg1)->AddAngle(arg2);
40890     } catch (std::out_of_range& e) {
40891       {
40892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40893       };
40894     } catch (std::exception& e) {
40895       {
40896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40897       };
40898     } catch (Dali::DaliException e) {
40899       {
40900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40901       };
40902     } catch (...) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40905       };
40906     }
40907   }
40908
40909 }
40910
40911
40912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40913   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40914   Dali::Radian arg2 ;
40915   Dali::Radian arg3 ;
40916   Dali::Radian *argp2 ;
40917   Dali::Radian *argp3 ;
40918
40919   arg1 = (Dali::PanGestureDetector *)jarg1;
40920   argp2 = (Dali::Radian *)jarg2;
40921   if (!argp2) {
40922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40923     return ;
40924   }
40925   arg2 = *argp2;
40926   argp3 = (Dali::Radian *)jarg3;
40927   if (!argp3) {
40928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40929     return ;
40930   }
40931   arg3 = *argp3;
40932   {
40933     try {
40934       (arg1)->AddDirection(arg2,arg3);
40935     } catch (std::out_of_range& e) {
40936       {
40937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40938       };
40939     } catch (std::exception& e) {
40940       {
40941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40942       };
40943     } catch (Dali::DaliException e) {
40944       {
40945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40946       };
40947     } catch (...) {
40948       {
40949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40950       };
40951     }
40952   }
40953
40954 }
40955
40956
40957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40958   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40959   Dali::Radian arg2 ;
40960   Dali::Radian *argp2 ;
40961
40962   arg1 = (Dali::PanGestureDetector *)jarg1;
40963   argp2 = (Dali::Radian *)jarg2;
40964   if (!argp2) {
40965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40966     return ;
40967   }
40968   arg2 = *argp2;
40969   {
40970     try {
40971       (arg1)->AddDirection(arg2);
40972     } catch (std::out_of_range& e) {
40973       {
40974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40975       };
40976     } catch (std::exception& e) {
40977       {
40978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40979       };
40980     } catch (Dali::DaliException e) {
40981       {
40982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40983       };
40984     } catch (...) {
40985       {
40986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40987       };
40988     }
40989   }
40990
40991 }
40992
40993
40994 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40995   unsigned long jresult ;
40996   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40997   size_t result;
40998
40999   arg1 = (Dali::PanGestureDetector *)jarg1;
41000   {
41001     try {
41002       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41003     } catch (std::out_of_range& e) {
41004       {
41005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41006       };
41007     } catch (std::exception& e) {
41008       {
41009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41010       };
41011     } catch (Dali::DaliException e) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41014       };
41015     } catch (...) {
41016       {
41017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41018       };
41019     }
41020   }
41021
41022   jresult = (unsigned long)result;
41023   return jresult;
41024 }
41025
41026
41027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41028   void * jresult ;
41029   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41030   size_t arg2 ;
41031   Dali::PanGestureDetector::AngleThresholdPair result;
41032
41033   arg1 = (Dali::PanGestureDetector *)jarg1;
41034   arg2 = (size_t)jarg2;
41035   {
41036     try {
41037       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41038     } catch (std::out_of_range& e) {
41039       {
41040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41041       };
41042     } catch (std::exception& e) {
41043       {
41044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41045       };
41046     } catch (Dali::DaliException e) {
41047       {
41048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41049       };
41050     } catch (...) {
41051       {
41052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41053       };
41054     }
41055   }
41056
41057   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41058   return jresult;
41059 }
41060
41061
41062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41063   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41064
41065   arg1 = (Dali::PanGestureDetector *)jarg1;
41066   {
41067     try {
41068       (arg1)->ClearAngles();
41069     } catch (std::out_of_range& e) {
41070       {
41071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41072       };
41073     } catch (std::exception& e) {
41074       {
41075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41076       };
41077     } catch (Dali::DaliException e) {
41078       {
41079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41080       };
41081     } catch (...) {
41082       {
41083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41084       };
41085     }
41086   }
41087
41088 }
41089
41090
41091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41092   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41093   Dali::Radian arg2 ;
41094   Dali::Radian *argp2 ;
41095
41096   arg1 = (Dali::PanGestureDetector *)jarg1;
41097   argp2 = (Dali::Radian *)jarg2;
41098   if (!argp2) {
41099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41100     return ;
41101   }
41102   arg2 = *argp2;
41103   {
41104     try {
41105       (arg1)->RemoveAngle(arg2);
41106     } catch (std::out_of_range& e) {
41107       {
41108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41109       };
41110     } catch (std::exception& e) {
41111       {
41112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41113       };
41114     } catch (Dali::DaliException e) {
41115       {
41116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41117       };
41118     } catch (...) {
41119       {
41120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41121       };
41122     }
41123   }
41124
41125 }
41126
41127
41128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41129   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41130   Dali::Radian arg2 ;
41131   Dali::Radian *argp2 ;
41132
41133   arg1 = (Dali::PanGestureDetector *)jarg1;
41134   argp2 = (Dali::Radian *)jarg2;
41135   if (!argp2) {
41136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41137     return ;
41138   }
41139   arg2 = *argp2;
41140   {
41141     try {
41142       (arg1)->RemoveDirection(arg2);
41143     } catch (std::out_of_range& e) {
41144       {
41145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41146       };
41147     } catch (std::exception& e) {
41148       {
41149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41150       };
41151     } catch (Dali::DaliException e) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41158       };
41159     }
41160   }
41161
41162 }
41163
41164
41165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41166   void * jresult ;
41167   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41168   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41169
41170   arg1 = (Dali::PanGestureDetector *)jarg1;
41171   {
41172     try {
41173       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41174     } catch (std::out_of_range& e) {
41175       {
41176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41177       };
41178     } catch (std::exception& e) {
41179       {
41180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41181       };
41182     } catch (Dali::DaliException e) {
41183       {
41184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41185       };
41186     } catch (...) {
41187       {
41188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41189       };
41190     }
41191   }
41192
41193   jresult = (void *)result;
41194   return jresult;
41195 }
41196
41197
41198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41199   Dali::PanGesture *arg1 = 0 ;
41200
41201   arg1 = (Dali::PanGesture *)jarg1;
41202   if (!arg1) {
41203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41204     return ;
41205   }
41206   {
41207     try {
41208       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41209     } catch (std::out_of_range& e) {
41210       {
41211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41212       };
41213     } catch (std::exception& e) {
41214       {
41215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41216       };
41217     } catch (Dali::DaliException e) {
41218       {
41219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41220       };
41221     } catch (...) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41224       };
41225     }
41226   }
41227
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41232   void * jresult ;
41233   Dali::PanGesture *result = 0 ;
41234
41235   {
41236     try {
41237       result = (Dali::PanGesture *)new Dali::PanGesture();
41238     } catch (std::out_of_range& e) {
41239       {
41240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41241       };
41242     } catch (std::exception& e) {
41243       {
41244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41245       };
41246     } catch (Dali::DaliException e) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41249       };
41250     } catch (...) {
41251       {
41252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41253       };
41254     }
41255   }
41256
41257   jresult = (void *)result;
41258   return jresult;
41259 }
41260
41261
41262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41263   void * jresult ;
41264   Dali::Gesture::State arg1 ;
41265   Dali::PanGesture *result = 0 ;
41266
41267   arg1 = (Dali::Gesture::State)jarg1;
41268   {
41269     try {
41270       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41271     } catch (std::out_of_range& e) {
41272       {
41273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41274       };
41275     } catch (std::exception& e) {
41276       {
41277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41278       };
41279     } catch (Dali::DaliException e) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41282       };
41283     } catch (...) {
41284       {
41285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41286       };
41287     }
41288   }
41289
41290   jresult = (void *)result;
41291   return jresult;
41292 }
41293
41294
41295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41296   void * jresult ;
41297   Dali::PanGesture *arg1 = 0 ;
41298   Dali::PanGesture *result = 0 ;
41299
41300   arg1 = (Dali::PanGesture *)jarg1;
41301   if (!arg1) {
41302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41303     return 0;
41304   }
41305   {
41306     try {
41307       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41308     } catch (std::out_of_range& e) {
41309       {
41310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41311       };
41312     } catch (std::exception& e) {
41313       {
41314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41315       };
41316     } catch (Dali::DaliException e) {
41317       {
41318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41319       };
41320     } catch (...) {
41321       {
41322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41323       };
41324     }
41325   }
41326
41327   jresult = (void *)result;
41328   return jresult;
41329 }
41330
41331
41332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41333   void * jresult ;
41334   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41335   Dali::PanGesture *arg2 = 0 ;
41336   Dali::PanGesture *result = 0 ;
41337
41338   arg1 = (Dali::PanGesture *)jarg1;
41339   arg2 = (Dali::PanGesture *)jarg2;
41340   if (!arg2) {
41341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41342     return 0;
41343   }
41344   {
41345     try {
41346       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41347     } catch (std::out_of_range& e) {
41348       {
41349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41350       };
41351     } catch (std::exception& e) {
41352       {
41353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41354       };
41355     } catch (Dali::DaliException e) {
41356       {
41357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41358       };
41359     } catch (...) {
41360       {
41361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41362       };
41363     }
41364   }
41365
41366   jresult = (void *)result;
41367   return jresult;
41368 }
41369
41370
41371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41372   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41373
41374   arg1 = (Dali::PanGesture *)jarg1;
41375   {
41376     try {
41377       delete arg1;
41378     } catch (std::out_of_range& e) {
41379       {
41380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41381       };
41382     } catch (std::exception& e) {
41383       {
41384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41385       };
41386     } catch (Dali::DaliException e) {
41387       {
41388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41389       };
41390     } catch (...) {
41391       {
41392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41393       };
41394     }
41395   }
41396
41397 }
41398
41399
41400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41401   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41402   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41403
41404   arg1 = (Dali::PanGesture *)jarg1;
41405   arg2 = (Dali::Vector2 *)jarg2;
41406   if (arg1) (arg1)->velocity = *arg2;
41407 }
41408
41409
41410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41411   void * jresult ;
41412   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41413   Dali::Vector2 *result = 0 ;
41414
41415   arg1 = (Dali::PanGesture *)jarg1;
41416   result = (Dali::Vector2 *)& ((arg1)->velocity);
41417   jresult = (void *)result;
41418   return jresult;
41419 }
41420
41421
41422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41423   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41424   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41425
41426   arg1 = (Dali::PanGesture *)jarg1;
41427   arg2 = (Dali::Vector2 *)jarg2;
41428   if (arg1) (arg1)->displacement = *arg2;
41429 }
41430
41431
41432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41433   void * jresult ;
41434   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41435   Dali::Vector2 *result = 0 ;
41436
41437   arg1 = (Dali::PanGesture *)jarg1;
41438   result = (Dali::Vector2 *)& ((arg1)->displacement);
41439   jresult = (void *)result;
41440   return jresult;
41441 }
41442
41443
41444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41445   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41446   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41447
41448   arg1 = (Dali::PanGesture *)jarg1;
41449   arg2 = (Dali::Vector2 *)jarg2;
41450   if (arg1) (arg1)->position = *arg2;
41451 }
41452
41453
41454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41455   void * jresult ;
41456   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41457   Dali::Vector2 *result = 0 ;
41458
41459   arg1 = (Dali::PanGesture *)jarg1;
41460   result = (Dali::Vector2 *)& ((arg1)->position);
41461   jresult = (void *)result;
41462   return jresult;
41463 }
41464
41465
41466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41467   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41468   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41469
41470   arg1 = (Dali::PanGesture *)jarg1;
41471   arg2 = (Dali::Vector2 *)jarg2;
41472   if (arg1) (arg1)->screenVelocity = *arg2;
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41477   void * jresult ;
41478   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41479   Dali::Vector2 *result = 0 ;
41480
41481   arg1 = (Dali::PanGesture *)jarg1;
41482   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41483   jresult = (void *)result;
41484   return jresult;
41485 }
41486
41487
41488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41489   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41490   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41491
41492   arg1 = (Dali::PanGesture *)jarg1;
41493   arg2 = (Dali::Vector2 *)jarg2;
41494   if (arg1) (arg1)->screenDisplacement = *arg2;
41495 }
41496
41497
41498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41499   void * jresult ;
41500   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41501   Dali::Vector2 *result = 0 ;
41502
41503   arg1 = (Dali::PanGesture *)jarg1;
41504   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41505   jresult = (void *)result;
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41511   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41512   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41513
41514   arg1 = (Dali::PanGesture *)jarg1;
41515   arg2 = (Dali::Vector2 *)jarg2;
41516   if (arg1) (arg1)->screenPosition = *arg2;
41517 }
41518
41519
41520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41521   void * jresult ;
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *result = 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41527   jresult = (void *)result;
41528   return jresult;
41529 }
41530
41531
41532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   unsigned int arg2 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   arg2 = (unsigned int)jarg2;
41538   if (arg1) (arg1)->numberOfTouches = arg2;
41539 }
41540
41541
41542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41543   unsigned int jresult ;
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   unsigned int result;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   result = (unsigned int) ((arg1)->numberOfTouches);
41549   jresult = result;
41550   return jresult;
41551 }
41552
41553
41554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41555   float jresult ;
41556   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41557   float result;
41558
41559   arg1 = (Dali::PanGesture *)jarg1;
41560   {
41561     try {
41562       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41563     } catch (std::out_of_range& e) {
41564       {
41565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41566       };
41567     } catch (std::exception& e) {
41568       {
41569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41570       };
41571     } catch (Dali::DaliException e) {
41572       {
41573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41574       };
41575     } catch (...) {
41576       {
41577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41578       };
41579     }
41580   }
41581
41582   jresult = result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41588   float jresult ;
41589   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41590   float result;
41591
41592   arg1 = (Dali::PanGesture *)jarg1;
41593   {
41594     try {
41595       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41596     } catch (std::out_of_range& e) {
41597       {
41598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41599       };
41600     } catch (std::exception& e) {
41601       {
41602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41603       };
41604     } catch (Dali::DaliException e) {
41605       {
41606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41607       };
41608     } catch (...) {
41609       {
41610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41611       };
41612     }
41613   }
41614
41615   jresult = result;
41616   return jresult;
41617 }
41618
41619
41620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41621   float jresult ;
41622   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41623   float result;
41624
41625   arg1 = (Dali::PanGesture *)jarg1;
41626   {
41627     try {
41628       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41629     } catch (std::out_of_range& e) {
41630       {
41631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (std::exception& e) {
41634       {
41635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41636       };
41637     } catch (Dali::DaliException e) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41640       };
41641     } catch (...) {
41642       {
41643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41644       };
41645     }
41646   }
41647
41648   jresult = result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41654   float jresult ;
41655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41656   float result;
41657
41658   arg1 = (Dali::PanGesture *)jarg1;
41659   {
41660     try {
41661       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41662     } catch (std::out_of_range& e) {
41663       {
41664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (std::exception& e) {
41667       {
41668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (Dali::DaliException e) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41673       };
41674     } catch (...) {
41675       {
41676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41677       };
41678     }
41679   }
41680
41681   jresult = result;
41682   return jresult;
41683 }
41684
41685
41686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41687   void * jresult ;
41688   Dali::PinchGestureDetector *result = 0 ;
41689
41690   {
41691     try {
41692       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41693     } catch (std::out_of_range& e) {
41694       {
41695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41696       };
41697     } catch (std::exception& e) {
41698       {
41699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (Dali::DaliException e) {
41702       {
41703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41704       };
41705     } catch (...) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41708       };
41709     }
41710   }
41711
41712   jresult = (void *)result;
41713   return jresult;
41714 }
41715
41716
41717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41718   void * jresult ;
41719   Dali::PinchGestureDetector result;
41720
41721   {
41722     try {
41723       result = Dali::PinchGestureDetector::New();
41724     } catch (std::out_of_range& e) {
41725       {
41726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41727       };
41728     } catch (std::exception& e) {
41729       {
41730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41731       };
41732     } catch (Dali::DaliException e) {
41733       {
41734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41735       };
41736     } catch (...) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41739       };
41740     }
41741   }
41742
41743   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41749   void * jresult ;
41750   Dali::BaseHandle arg1 ;
41751   Dali::BaseHandle *argp1 ;
41752   Dali::PinchGestureDetector result;
41753
41754   argp1 = (Dali::BaseHandle *)jarg1;
41755   if (!argp1) {
41756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41757     return 0;
41758   }
41759   arg1 = *argp1;
41760   {
41761     try {
41762       result = Dali::PinchGestureDetector::DownCast(arg1);
41763     } catch (std::out_of_range& e) {
41764       {
41765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41766       };
41767     } catch (std::exception& e) {
41768       {
41769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41770       };
41771     } catch (Dali::DaliException e) {
41772       {
41773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41774       };
41775     } catch (...) {
41776       {
41777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41778       };
41779     }
41780   }
41781
41782   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41783   return jresult;
41784 }
41785
41786
41787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41788   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41789
41790   arg1 = (Dali::PinchGestureDetector *)jarg1;
41791   {
41792     try {
41793       delete arg1;
41794     } catch (std::out_of_range& e) {
41795       {
41796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41797       };
41798     } catch (std::exception& e) {
41799       {
41800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41801       };
41802     } catch (Dali::DaliException e) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41805       };
41806     } catch (...) {
41807       {
41808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41809       };
41810     }
41811   }
41812
41813 }
41814
41815
41816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41817   void * jresult ;
41818   Dali::PinchGestureDetector *arg1 = 0 ;
41819   Dali::PinchGestureDetector *result = 0 ;
41820
41821   arg1 = (Dali::PinchGestureDetector *)jarg1;
41822   if (!arg1) {
41823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41824     return 0;
41825   }
41826   {
41827     try {
41828       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41829     } catch (std::out_of_range& e) {
41830       {
41831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41832       };
41833     } catch (std::exception& e) {
41834       {
41835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41836       };
41837     } catch (Dali::DaliException e) {
41838       {
41839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41840       };
41841     } catch (...) {
41842       {
41843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41844       };
41845     }
41846   }
41847
41848   jresult = (void *)result;
41849   return jresult;
41850 }
41851
41852
41853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41854   void * jresult ;
41855   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41856   Dali::PinchGestureDetector *arg2 = 0 ;
41857   Dali::PinchGestureDetector *result = 0 ;
41858
41859   arg1 = (Dali::PinchGestureDetector *)jarg1;
41860   arg2 = (Dali::PinchGestureDetector *)jarg2;
41861   if (!arg2) {
41862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41863     return 0;
41864   }
41865   {
41866     try {
41867       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41868     } catch (std::out_of_range& e) {
41869       {
41870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41871       };
41872     } catch (std::exception& e) {
41873       {
41874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41875       };
41876     } catch (Dali::DaliException e) {
41877       {
41878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41879       };
41880     } catch (...) {
41881       {
41882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41883       };
41884     }
41885   }
41886
41887   jresult = (void *)result;
41888   return jresult;
41889 }
41890
41891
41892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41893   void * jresult ;
41894   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41895   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41896
41897   arg1 = (Dali::PinchGestureDetector *)jarg1;
41898   {
41899     try {
41900       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41901     } catch (std::out_of_range& e) {
41902       {
41903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (std::exception& e) {
41906       {
41907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41908       };
41909     } catch (Dali::DaliException e) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41912       };
41913     } catch (...) {
41914       {
41915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41916       };
41917     }
41918   }
41919
41920   jresult = (void *)result;
41921   return jresult;
41922 }
41923
41924
41925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41926   void * jresult ;
41927   Dali::Gesture::State arg1 ;
41928   Dali::PinchGesture *result = 0 ;
41929
41930   arg1 = (Dali::Gesture::State)jarg1;
41931   {
41932     try {
41933       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41934     } catch (std::out_of_range& e) {
41935       {
41936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (std::exception& e) {
41939       {
41940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41941       };
41942     } catch (Dali::DaliException e) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41945       };
41946     } catch (...) {
41947       {
41948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41949       };
41950     }
41951   }
41952
41953   jresult = (void *)result;
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41959   void * jresult ;
41960   Dali::PinchGesture *arg1 = 0 ;
41961   Dali::PinchGesture *result = 0 ;
41962
41963   arg1 = (Dali::PinchGesture *)jarg1;
41964   if (!arg1) {
41965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41966     return 0;
41967   }
41968   {
41969     try {
41970       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41971     } catch (std::out_of_range& e) {
41972       {
41973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41974       };
41975     } catch (std::exception& e) {
41976       {
41977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41978       };
41979     } catch (Dali::DaliException e) {
41980       {
41981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41982       };
41983     } catch (...) {
41984       {
41985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41986       };
41987     }
41988   }
41989
41990   jresult = (void *)result;
41991   return jresult;
41992 }
41993
41994
41995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41996   void * jresult ;
41997   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41998   Dali::PinchGesture *arg2 = 0 ;
41999   Dali::PinchGesture *result = 0 ;
42000
42001   arg1 = (Dali::PinchGesture *)jarg1;
42002   arg2 = (Dali::PinchGesture *)jarg2;
42003   if (!arg2) {
42004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42005     return 0;
42006   }
42007   {
42008     try {
42009       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42010     } catch (std::out_of_range& e) {
42011       {
42012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42013       };
42014     } catch (std::exception& e) {
42015       {
42016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42017       };
42018     } catch (Dali::DaliException e) {
42019       {
42020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42021       };
42022     } catch (...) {
42023       {
42024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42025       };
42026     }
42027   }
42028
42029   jresult = (void *)result;
42030   return jresult;
42031 }
42032
42033
42034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42035   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42036
42037   arg1 = (Dali::PinchGesture *)jarg1;
42038   {
42039     try {
42040       delete arg1;
42041     } catch (std::out_of_range& e) {
42042       {
42043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42044       };
42045     } catch (std::exception& e) {
42046       {
42047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42048       };
42049     } catch (Dali::DaliException e) {
42050       {
42051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42052       };
42053     } catch (...) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42056       };
42057     }
42058   }
42059
42060 }
42061
42062
42063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42064   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42065   float arg2 ;
42066
42067   arg1 = (Dali::PinchGesture *)jarg1;
42068   arg2 = (float)jarg2;
42069   if (arg1) (arg1)->scale = arg2;
42070 }
42071
42072
42073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42074   float jresult ;
42075   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42076   float result;
42077
42078   arg1 = (Dali::PinchGesture *)jarg1;
42079   result = (float) ((arg1)->scale);
42080   jresult = result;
42081   return jresult;
42082 }
42083
42084
42085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42086   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42087   float arg2 ;
42088
42089   arg1 = (Dali::PinchGesture *)jarg1;
42090   arg2 = (float)jarg2;
42091   if (arg1) (arg1)->speed = arg2;
42092 }
42093
42094
42095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42096   float jresult ;
42097   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42098   float result;
42099
42100   arg1 = (Dali::PinchGesture *)jarg1;
42101   result = (float) ((arg1)->speed);
42102   jresult = result;
42103   return jresult;
42104 }
42105
42106
42107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42108   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42109   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42110
42111   arg1 = (Dali::PinchGesture *)jarg1;
42112   arg2 = (Dali::Vector2 *)jarg2;
42113   if (arg1) (arg1)->screenCenterPoint = *arg2;
42114 }
42115
42116
42117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42118   void * jresult ;
42119   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42120   Dali::Vector2 *result = 0 ;
42121
42122   arg1 = (Dali::PinchGesture *)jarg1;
42123   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42124   jresult = (void *)result;
42125   return jresult;
42126 }
42127
42128
42129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42130   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42131   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42132
42133   arg1 = (Dali::PinchGesture *)jarg1;
42134   arg2 = (Dali::Vector2 *)jarg2;
42135   if (arg1) (arg1)->localCenterPoint = *arg2;
42136 }
42137
42138
42139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42140   void * jresult ;
42141   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42142   Dali::Vector2 *result = 0 ;
42143
42144   arg1 = (Dali::PinchGesture *)jarg1;
42145   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42146   jresult = (void *)result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42152   void * jresult ;
42153   Dali::TapGestureDetector *result = 0 ;
42154
42155   {
42156     try {
42157       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42158     } catch (std::out_of_range& e) {
42159       {
42160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42161       };
42162     } catch (std::exception& e) {
42163       {
42164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42165       };
42166     } catch (Dali::DaliException e) {
42167       {
42168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42169       };
42170     } catch (...) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42173       };
42174     }
42175   }
42176
42177   jresult = (void *)result;
42178   return jresult;
42179 }
42180
42181
42182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42183   void * jresult ;
42184   Dali::TapGestureDetector result;
42185
42186   {
42187     try {
42188       result = Dali::TapGestureDetector::New();
42189     } catch (std::out_of_range& e) {
42190       {
42191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42192       };
42193     } catch (std::exception& e) {
42194       {
42195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42196       };
42197     } catch (Dali::DaliException e) {
42198       {
42199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42200       };
42201     } catch (...) {
42202       {
42203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42204       };
42205     }
42206   }
42207
42208   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42209   return jresult;
42210 }
42211
42212
42213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42214   void * jresult ;
42215   unsigned int arg1 ;
42216   Dali::TapGestureDetector result;
42217
42218   arg1 = (unsigned int)jarg1;
42219   {
42220     try {
42221       result = Dali::TapGestureDetector::New(arg1);
42222     } catch (std::out_of_range& e) {
42223       {
42224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (std::exception& e) {
42227       {
42228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42229       };
42230     } catch (Dali::DaliException e) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42233       };
42234     } catch (...) {
42235       {
42236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42237       };
42238     }
42239   }
42240
42241   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42242   return jresult;
42243 }
42244
42245
42246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42247   void * jresult ;
42248   Dali::BaseHandle arg1 ;
42249   Dali::BaseHandle *argp1 ;
42250   Dali::TapGestureDetector result;
42251
42252   argp1 = (Dali::BaseHandle *)jarg1;
42253   if (!argp1) {
42254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42255     return 0;
42256   }
42257   arg1 = *argp1;
42258   {
42259     try {
42260       result = Dali::TapGestureDetector::DownCast(arg1);
42261     } catch (std::out_of_range& e) {
42262       {
42263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42264       };
42265     } catch (std::exception& e) {
42266       {
42267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42268       };
42269     } catch (Dali::DaliException e) {
42270       {
42271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42272       };
42273     } catch (...) {
42274       {
42275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42276       };
42277     }
42278   }
42279
42280   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42281   return jresult;
42282 }
42283
42284
42285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42286   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42287
42288   arg1 = (Dali::TapGestureDetector *)jarg1;
42289   {
42290     try {
42291       delete arg1;
42292     } catch (std::out_of_range& e) {
42293       {
42294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42295       };
42296     } catch (std::exception& e) {
42297       {
42298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42299       };
42300     } catch (Dali::DaliException e) {
42301       {
42302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42303       };
42304     } catch (...) {
42305       {
42306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42307       };
42308     }
42309   }
42310
42311 }
42312
42313
42314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42315   void * jresult ;
42316   Dali::TapGestureDetector *arg1 = 0 ;
42317   Dali::TapGestureDetector *result = 0 ;
42318
42319   arg1 = (Dali::TapGestureDetector *)jarg1;
42320   if (!arg1) {
42321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42322     return 0;
42323   }
42324   {
42325     try {
42326       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42327     } catch (std::out_of_range& e) {
42328       {
42329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42330       };
42331     } catch (std::exception& e) {
42332       {
42333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42334       };
42335     } catch (Dali::DaliException e) {
42336       {
42337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42338       };
42339     } catch (...) {
42340       {
42341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42342       };
42343     }
42344   }
42345
42346   jresult = (void *)result;
42347   return jresult;
42348 }
42349
42350
42351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42352   void * jresult ;
42353   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42354   Dali::TapGestureDetector *arg2 = 0 ;
42355   Dali::TapGestureDetector *result = 0 ;
42356
42357   arg1 = (Dali::TapGestureDetector *)jarg1;
42358   arg2 = (Dali::TapGestureDetector *)jarg2;
42359   if (!arg2) {
42360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42361     return 0;
42362   }
42363   {
42364     try {
42365       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42366     } catch (std::out_of_range& e) {
42367       {
42368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (std::exception& e) {
42371       {
42372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (Dali::DaliException e) {
42375       {
42376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42377       };
42378     } catch (...) {
42379       {
42380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42381       };
42382     }
42383   }
42384
42385   jresult = (void *)result;
42386   return jresult;
42387 }
42388
42389
42390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42391   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42392   unsigned int arg2 ;
42393
42394   arg1 = (Dali::TapGestureDetector *)jarg1;
42395   arg2 = (unsigned int)jarg2;
42396   {
42397     try {
42398       (arg1)->SetMinimumTapsRequired(arg2);
42399     } catch (std::out_of_range& e) {
42400       {
42401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42402       };
42403     } catch (std::exception& e) {
42404       {
42405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42406       };
42407     } catch (Dali::DaliException e) {
42408       {
42409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42410       };
42411     } catch (...) {
42412       {
42413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42414       };
42415     }
42416   }
42417
42418 }
42419
42420
42421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42422   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42423   unsigned int arg2 ;
42424
42425   arg1 = (Dali::TapGestureDetector *)jarg1;
42426   arg2 = (unsigned int)jarg2;
42427   {
42428     try {
42429       (arg1)->SetMaximumTapsRequired(arg2);
42430     } catch (std::out_of_range& e) {
42431       {
42432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42433       };
42434     } catch (std::exception& e) {
42435       {
42436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42437       };
42438     } catch (Dali::DaliException e) {
42439       {
42440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42441       };
42442     } catch (...) {
42443       {
42444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42445       };
42446     }
42447   }
42448
42449 }
42450
42451
42452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42453   unsigned int jresult ;
42454   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42455   unsigned int result;
42456
42457   arg1 = (Dali::TapGestureDetector *)jarg1;
42458   {
42459     try {
42460       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42461     } catch (std::out_of_range& e) {
42462       {
42463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42464       };
42465     } catch (std::exception& e) {
42466       {
42467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42468       };
42469     } catch (Dali::DaliException e) {
42470       {
42471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42472       };
42473     } catch (...) {
42474       {
42475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42476       };
42477     }
42478   }
42479
42480   jresult = result;
42481   return jresult;
42482 }
42483
42484
42485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42486   unsigned int jresult ;
42487   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42488   unsigned int result;
42489
42490   arg1 = (Dali::TapGestureDetector *)jarg1;
42491   {
42492     try {
42493       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42494     } catch (std::out_of_range& e) {
42495       {
42496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42497       };
42498     } catch (std::exception& e) {
42499       {
42500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42501       };
42502     } catch (Dali::DaliException e) {
42503       {
42504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42505       };
42506     } catch (...) {
42507       {
42508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42509       };
42510     }
42511   }
42512
42513   jresult = result;
42514   return jresult;
42515 }
42516
42517
42518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42519   void * jresult ;
42520   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42521   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42522
42523   arg1 = (Dali::TapGestureDetector *)jarg1;
42524   {
42525     try {
42526       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42527     } catch (std::out_of_range& e) {
42528       {
42529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (std::exception& e) {
42532       {
42533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (Dali::DaliException e) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545
42546   jresult = (void *)result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42552   void * jresult ;
42553   Dali::TapGesture *result = 0 ;
42554
42555   {
42556     try {
42557       result = (Dali::TapGesture *)new Dali::TapGesture();
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42565       };
42566     } catch (Dali::DaliException e) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42573       };
42574     }
42575   }
42576
42577   jresult = (void *)result;
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42583   void * jresult ;
42584   Dali::TapGesture *arg1 = 0 ;
42585   Dali::TapGesture *result = 0 ;
42586
42587   arg1 = (Dali::TapGesture *)jarg1;
42588   if (!arg1) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42590     return 0;
42591   }
42592   {
42593     try {
42594       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42595     } catch (std::out_of_range& e) {
42596       {
42597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42598       };
42599     } catch (std::exception& e) {
42600       {
42601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42602       };
42603     } catch (Dali::DaliException e) {
42604       {
42605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42606       };
42607     } catch (...) {
42608       {
42609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42610       };
42611     }
42612   }
42613
42614   jresult = (void *)result;
42615   return jresult;
42616 }
42617
42618
42619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42620   void * jresult ;
42621   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42622   Dali::TapGesture *arg2 = 0 ;
42623   Dali::TapGesture *result = 0 ;
42624
42625   arg1 = (Dali::TapGesture *)jarg1;
42626   arg2 = (Dali::TapGesture *)jarg2;
42627   if (!arg2) {
42628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42629     return 0;
42630   }
42631   {
42632     try {
42633       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42634     } catch (std::out_of_range& e) {
42635       {
42636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42637       };
42638     } catch (std::exception& e) {
42639       {
42640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42641       };
42642     } catch (Dali::DaliException e) {
42643       {
42644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42645       };
42646     } catch (...) {
42647       {
42648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42649       };
42650     }
42651   }
42652
42653   jresult = (void *)result;
42654   return jresult;
42655 }
42656
42657
42658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42659   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42660
42661   arg1 = (Dali::TapGesture *)jarg1;
42662   {
42663     try {
42664       delete arg1;
42665     } catch (std::out_of_range& e) {
42666       {
42667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42668       };
42669     } catch (std::exception& e) {
42670       {
42671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42672       };
42673     } catch (Dali::DaliException e) {
42674       {
42675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42676       };
42677     } catch (...) {
42678       {
42679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42680       };
42681     }
42682   }
42683
42684 }
42685
42686
42687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42688   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42689   unsigned int arg2 ;
42690
42691   arg1 = (Dali::TapGesture *)jarg1;
42692   arg2 = (unsigned int)jarg2;
42693   if (arg1) (arg1)->numberOfTaps = arg2;
42694 }
42695
42696
42697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42698   unsigned int jresult ;
42699   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42700   unsigned int result;
42701
42702   arg1 = (Dali::TapGesture *)jarg1;
42703   result = (unsigned int) ((arg1)->numberOfTaps);
42704   jresult = result;
42705   return jresult;
42706 }
42707
42708
42709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42710   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42711   unsigned int arg2 ;
42712
42713   arg1 = (Dali::TapGesture *)jarg1;
42714   arg2 = (unsigned int)jarg2;
42715   if (arg1) (arg1)->numberOfTouches = arg2;
42716 }
42717
42718
42719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42720   unsigned int jresult ;
42721   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42722   unsigned int result;
42723
42724   arg1 = (Dali::TapGesture *)jarg1;
42725   result = (unsigned int) ((arg1)->numberOfTouches);
42726   jresult = result;
42727   return jresult;
42728 }
42729
42730
42731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42732   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42733   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42734
42735   arg1 = (Dali::TapGesture *)jarg1;
42736   arg2 = (Dali::Vector2 *)jarg2;
42737   if (arg1) (arg1)->screenPoint = *arg2;
42738 }
42739
42740
42741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42742   void * jresult ;
42743   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42744   Dali::Vector2 *result = 0 ;
42745
42746   arg1 = (Dali::TapGesture *)jarg1;
42747   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42748   jresult = (void *)result;
42749   return jresult;
42750 }
42751
42752
42753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42754   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42755   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42756
42757   arg1 = (Dali::TapGesture *)jarg1;
42758   arg2 = (Dali::Vector2 *)jarg2;
42759   if (arg1) (arg1)->localPoint = *arg2;
42760 }
42761
42762
42763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42764   void * jresult ;
42765   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42766   Dali::Vector2 *result = 0 ;
42767
42768   arg1 = (Dali::TapGesture *)jarg1;
42769   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42770   jresult = (void *)result;
42771   return jresult;
42772 }
42773
42774
42775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42776   void * jresult ;
42777   Dali::AlphaFunction *result = 0 ;
42778
42779   {
42780     try {
42781       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42782     } catch (std::out_of_range& e) {
42783       {
42784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42785       };
42786     } catch (std::exception& e) {
42787       {
42788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42789       };
42790     } catch (Dali::DaliException e) {
42791       {
42792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42793       };
42794     } catch (...) {
42795       {
42796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42797       };
42798     }
42799   }
42800
42801   jresult = (void *)result;
42802   return jresult;
42803 }
42804
42805
42806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42807   void * jresult ;
42808   Dali::AlphaFunction::BuiltinFunction arg1 ;
42809   Dali::AlphaFunction *result = 0 ;
42810
42811   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42812   {
42813     try {
42814       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42815     } catch (std::out_of_range& e) {
42816       {
42817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (std::exception& e) {
42820       {
42821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42822       };
42823     } catch (Dali::DaliException e) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42826       };
42827     } catch (...) {
42828       {
42829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42830       };
42831     }
42832   }
42833
42834   jresult = (void *)result;
42835   return jresult;
42836 }
42837
42838
42839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42840   void * jresult ;
42841   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42842   Dali::AlphaFunction *result = 0 ;
42843
42844   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42845   {
42846     try {
42847       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (Dali::DaliException e) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42859       };
42860     } catch (...) {
42861       {
42862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42863       };
42864     }
42865   }
42866
42867   jresult = (void *)result;
42868   return jresult;
42869 }
42870
42871
42872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42873   void * jresult ;
42874   Dali::Vector2 *arg1 = 0 ;
42875   Dali::Vector2 *arg2 = 0 ;
42876   Dali::AlphaFunction *result = 0 ;
42877
42878   arg1 = (Dali::Vector2 *)jarg1;
42879   if (!arg1) {
42880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42881     return 0;
42882   }
42883   arg2 = (Dali::Vector2 *)jarg2;
42884   if (!arg2) {
42885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42886     return 0;
42887   }
42888   {
42889     try {
42890       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42891     } catch (std::out_of_range& e) {
42892       {
42893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42894       };
42895     } catch (std::exception& e) {
42896       {
42897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42898       };
42899     } catch (Dali::DaliException e) {
42900       {
42901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42902       };
42903     } catch (...) {
42904       {
42905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42906       };
42907     }
42908   }
42909
42910   jresult = (void *)result;
42911   return jresult;
42912 }
42913
42914
42915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42916   void * jresult ;
42917   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42918   Dali::Vector4 result;
42919
42920   arg1 = (Dali::AlphaFunction *)jarg1;
42921   {
42922     try {
42923       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42924     } catch (std::out_of_range& e) {
42925       {
42926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (std::exception& e) {
42929       {
42930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42931       };
42932     } catch (Dali::DaliException e) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42935       };
42936     } catch (...) {
42937       {
42938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42939       };
42940     }
42941   }
42942
42943   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42949   void * jresult ;
42950   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42951   Dali::AlphaFunctionPrototype result;
42952
42953   arg1 = (Dali::AlphaFunction *)jarg1;
42954   {
42955     try {
42956       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42957     } catch (std::out_of_range& e) {
42958       {
42959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (std::exception& e) {
42962       {
42963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42964       };
42965     } catch (Dali::DaliException e) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42968       };
42969     } catch (...) {
42970       {
42971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42972       };
42973     }
42974   }
42975
42976   jresult = (void *)result;
42977   return jresult;
42978 }
42979
42980
42981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42982   int jresult ;
42983   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42984   Dali::AlphaFunction::BuiltinFunction result;
42985
42986   arg1 = (Dali::AlphaFunction *)jarg1;
42987   {
42988     try {
42989       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42990     } catch (std::out_of_range& e) {
42991       {
42992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42993       };
42994     } catch (std::exception& e) {
42995       {
42996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42997       };
42998     } catch (Dali::DaliException e) {
42999       {
43000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43001       };
43002     } catch (...) {
43003       {
43004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43005       };
43006     }
43007   }
43008
43009   jresult = (int)result;
43010   return jresult;
43011 }
43012
43013
43014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43015   int jresult ;
43016   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43017   Dali::AlphaFunction::Mode result;
43018
43019   arg1 = (Dali::AlphaFunction *)jarg1;
43020   {
43021     try {
43022       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43023     } catch (std::out_of_range& e) {
43024       {
43025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (std::exception& e) {
43028       {
43029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (Dali::DaliException e) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43034       };
43035     } catch (...) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43038       };
43039     }
43040   }
43041
43042   jresult = (int)result;
43043   return jresult;
43044 }
43045
43046
43047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43048   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43049
43050   arg1 = (Dali::AlphaFunction *)jarg1;
43051   {
43052     try {
43053       delete arg1;
43054     } catch (std::out_of_range& e) {
43055       {
43056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43057       };
43058     } catch (std::exception& e) {
43059       {
43060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43061       };
43062     } catch (Dali::DaliException e) {
43063       {
43064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43065       };
43066     } catch (...) {
43067       {
43068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43069       };
43070     }
43071   }
43072
43073 }
43074
43075
43076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43077   void * jresult ;
43078   Dali::KeyFrames result;
43079
43080   {
43081     try {
43082       result = Dali::KeyFrames::New();
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43098       };
43099     }
43100   }
43101
43102   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43108   void * jresult ;
43109   Dali::BaseHandle arg1 ;
43110   Dali::BaseHandle *argp1 ;
43111   Dali::KeyFrames result;
43112
43113   argp1 = (Dali::BaseHandle *)jarg1;
43114   if (!argp1) {
43115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43116     return 0;
43117   }
43118   arg1 = *argp1;
43119   {
43120     try {
43121       result = Dali::KeyFrames::DownCast(arg1);
43122     } catch (std::out_of_range& e) {
43123       {
43124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (std::exception& e) {
43127       {
43128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43129       };
43130     } catch (Dali::DaliException e) {
43131       {
43132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43133       };
43134     } catch (...) {
43135       {
43136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43137       };
43138     }
43139   }
43140
43141   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43142   return jresult;
43143 }
43144
43145
43146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43147   void * jresult ;
43148   Dali::KeyFrames *result = 0 ;
43149
43150   {
43151     try {
43152       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43153     } catch (std::out_of_range& e) {
43154       {
43155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (std::exception& e) {
43158       {
43159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43160       };
43161     } catch (Dali::DaliException e) {
43162       {
43163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43164       };
43165     } catch (...) {
43166       {
43167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43168       };
43169     }
43170   }
43171
43172   jresult = (void *)result;
43173   return jresult;
43174 }
43175
43176
43177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43178   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43179
43180   arg1 = (Dali::KeyFrames *)jarg1;
43181   {
43182     try {
43183       delete arg1;
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43199       };
43200     }
43201   }
43202
43203 }
43204
43205
43206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43207   void * jresult ;
43208   Dali::KeyFrames *arg1 = 0 ;
43209   Dali::KeyFrames *result = 0 ;
43210
43211   arg1 = (Dali::KeyFrames *)jarg1;
43212   if (!arg1) {
43213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43214     return 0;
43215   }
43216   {
43217     try {
43218       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43219     } catch (std::out_of_range& e) {
43220       {
43221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43222       };
43223     } catch (std::exception& e) {
43224       {
43225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43226       };
43227     } catch (Dali::DaliException e) {
43228       {
43229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43230       };
43231     } catch (...) {
43232       {
43233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43234       };
43235     }
43236   }
43237
43238   jresult = (void *)result;
43239   return jresult;
43240 }
43241
43242
43243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43244   void * jresult ;
43245   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43246   Dali::KeyFrames *arg2 = 0 ;
43247   Dali::KeyFrames *result = 0 ;
43248
43249   arg1 = (Dali::KeyFrames *)jarg1;
43250   arg2 = (Dali::KeyFrames *)jarg2;
43251   if (!arg2) {
43252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43253     return 0;
43254   }
43255   {
43256     try {
43257       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43265       };
43266     } catch (Dali::DaliException e) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43269       };
43270     } catch (...) {
43271       {
43272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43273       };
43274     }
43275   }
43276
43277   jresult = (void *)result;
43278   return jresult;
43279 }
43280
43281
43282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43283   int jresult ;
43284   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43285   Dali::Property::Type result;
43286
43287   arg1 = (Dali::KeyFrames *)jarg1;
43288   {
43289     try {
43290       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43291     } catch (std::out_of_range& e) {
43292       {
43293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43294       };
43295     } catch (std::exception& e) {
43296       {
43297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43298       };
43299     } catch (Dali::DaliException e) {
43300       {
43301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43302       };
43303     } catch (...) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43306       };
43307     }
43308   }
43309
43310   jresult = (int)result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43316   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43317   float arg2 ;
43318   Dali::Property::Value arg3 ;
43319   Dali::Property::Value *argp3 ;
43320
43321   arg1 = (Dali::KeyFrames *)jarg1;
43322   arg2 = (float)jarg2;
43323   argp3 = (Dali::Property::Value *)jarg3;
43324   if (!argp3) {
43325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43326     return ;
43327   }
43328   arg3 = *argp3;
43329   {
43330     try {
43331       (arg1)->Add(arg2,arg3);
43332     } catch (std::out_of_range& e) {
43333       {
43334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43335       };
43336     } catch (std::exception& e) {
43337       {
43338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43339       };
43340     } catch (Dali::DaliException e) {
43341       {
43342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43343       };
43344     } catch (...) {
43345       {
43346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43347       };
43348     }
43349   }
43350
43351 }
43352
43353
43354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43355   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43356   float arg2 ;
43357   Dali::Property::Value arg3 ;
43358   Dali::AlphaFunction arg4 ;
43359   Dali::Property::Value *argp3 ;
43360   Dali::AlphaFunction *argp4 ;
43361
43362   arg1 = (Dali::KeyFrames *)jarg1;
43363   arg2 = (float)jarg2;
43364   argp3 = (Dali::Property::Value *)jarg3;
43365   if (!argp3) {
43366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43367     return ;
43368   }
43369   arg3 = *argp3;
43370   argp4 = (Dali::AlphaFunction *)jarg4;
43371   if (!argp4) {
43372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43373     return ;
43374   }
43375   arg4 = *argp4;
43376   {
43377     try {
43378       (arg1)->Add(arg2,arg3,arg4);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43394       };
43395     }
43396   }
43397
43398 }
43399
43400
43401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43402   int jresult ;
43403   int result;
43404
43405   result = (int)Dali::Path::Property::POINTS;
43406   jresult = (int)result;
43407   return jresult;
43408 }
43409
43410
43411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43412   int jresult ;
43413   int result;
43414
43415   result = (int)Dali::Path::Property::CONTROL_POINTS;
43416   jresult = (int)result;
43417   return jresult;
43418 }
43419
43420
43421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43422   void * jresult ;
43423   Dali::Path::Property *result = 0 ;
43424
43425   {
43426     try {
43427       result = (Dali::Path::Property *)new Dali::Path::Property();
43428     } catch (std::out_of_range& e) {
43429       {
43430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43431       };
43432     } catch (std::exception& e) {
43433       {
43434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43435       };
43436     } catch (Dali::DaliException e) {
43437       {
43438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43439       };
43440     } catch (...) {
43441       {
43442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43443       };
43444     }
43445   }
43446
43447   jresult = (void *)result;
43448   return jresult;
43449 }
43450
43451
43452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43453   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43454
43455   arg1 = (Dali::Path::Property *)jarg1;
43456   {
43457     try {
43458       delete arg1;
43459     } catch (std::out_of_range& e) {
43460       {
43461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43462       };
43463     } catch (std::exception& e) {
43464       {
43465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43466       };
43467     } catch (Dali::DaliException e) {
43468       {
43469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43470       };
43471     } catch (...) {
43472       {
43473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43474       };
43475     }
43476   }
43477
43478 }
43479
43480
43481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43482   void * jresult ;
43483   Dali::Path result;
43484
43485   {
43486     try {
43487       result = Dali::Path::New();
43488     } catch (std::out_of_range& e) {
43489       {
43490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43491       };
43492     } catch (std::exception& e) {
43493       {
43494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43495       };
43496     } catch (Dali::DaliException e) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43499       };
43500     } catch (...) {
43501       {
43502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43503       };
43504     }
43505   }
43506
43507   jresult = new Dali::Path((const Dali::Path &)result);
43508   return jresult;
43509 }
43510
43511
43512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43513   void * jresult ;
43514   Dali::BaseHandle arg1 ;
43515   Dali::BaseHandle *argp1 ;
43516   Dali::Path result;
43517
43518   argp1 = (Dali::BaseHandle *)jarg1;
43519   if (!argp1) {
43520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43521     return 0;
43522   }
43523   arg1 = *argp1;
43524   {
43525     try {
43526       result = Dali::Path::DownCast(arg1);
43527     } catch (std::out_of_range& e) {
43528       {
43529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43530       };
43531     } catch (std::exception& e) {
43532       {
43533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43534       };
43535     } catch (Dali::DaliException e) {
43536       {
43537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43538       };
43539     } catch (...) {
43540       {
43541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43542       };
43543     }
43544   }
43545
43546   jresult = new Dali::Path((const Dali::Path &)result);
43547   return jresult;
43548 }
43549
43550
43551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43552   void * jresult ;
43553   Dali::Path *result = 0 ;
43554
43555   {
43556     try {
43557       result = (Dali::Path *)new Dali::Path();
43558     } catch (std::out_of_range& e) {
43559       {
43560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43561       };
43562     } catch (std::exception& e) {
43563       {
43564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43565       };
43566     } catch (Dali::DaliException e) {
43567       {
43568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43569       };
43570     } catch (...) {
43571       {
43572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43573       };
43574     }
43575   }
43576
43577   jresult = (void *)result;
43578   return jresult;
43579 }
43580
43581
43582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43583   Dali::Path *arg1 = (Dali::Path *) 0 ;
43584
43585   arg1 = (Dali::Path *)jarg1;
43586   {
43587     try {
43588       delete arg1;
43589     } catch (std::out_of_range& e) {
43590       {
43591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43592       };
43593     } catch (std::exception& e) {
43594       {
43595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43596       };
43597     } catch (Dali::DaliException e) {
43598       {
43599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43604       };
43605     }
43606   }
43607
43608 }
43609
43610
43611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43612   void * jresult ;
43613   Dali::Path *arg1 = 0 ;
43614   Dali::Path *result = 0 ;
43615
43616   arg1 = (Dali::Path *)jarg1;
43617   if (!arg1) {
43618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43619     return 0;
43620   }
43621   {
43622     try {
43623       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43624     } catch (std::out_of_range& e) {
43625       {
43626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (std::exception& e) {
43629       {
43630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (Dali::DaliException e) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43635       };
43636     } catch (...) {
43637       {
43638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43639       };
43640     }
43641   }
43642
43643   jresult = (void *)result;
43644   return jresult;
43645 }
43646
43647
43648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43649   void * jresult ;
43650   Dali::Path *arg1 = (Dali::Path *) 0 ;
43651   Dali::Path *arg2 = 0 ;
43652   Dali::Path *result = 0 ;
43653
43654   arg1 = (Dali::Path *)jarg1;
43655   arg2 = (Dali::Path *)jarg2;
43656   if (!arg2) {
43657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43658     return 0;
43659   }
43660   {
43661     try {
43662       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43663     } catch (std::out_of_range& e) {
43664       {
43665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43666       };
43667     } catch (std::exception& e) {
43668       {
43669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43670       };
43671     } catch (Dali::DaliException e) {
43672       {
43673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43674       };
43675     } catch (...) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43678       };
43679     }
43680   }
43681
43682   jresult = (void *)result;
43683   return jresult;
43684 }
43685
43686
43687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43688   Dali::Path *arg1 = (Dali::Path *) 0 ;
43689   Dali::Vector3 *arg2 = 0 ;
43690
43691   arg1 = (Dali::Path *)jarg1;
43692   arg2 = (Dali::Vector3 *)jarg2;
43693   if (!arg2) {
43694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43695     return ;
43696   }
43697   {
43698     try {
43699       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43700     } catch (std::out_of_range& e) {
43701       {
43702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43703       };
43704     } catch (std::exception& e) {
43705       {
43706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43707       };
43708     } catch (Dali::DaliException e) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43711       };
43712     } catch (...) {
43713       {
43714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43715       };
43716     }
43717   }
43718
43719 }
43720
43721
43722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43723   Dali::Path *arg1 = (Dali::Path *) 0 ;
43724   Dali::Vector3 *arg2 = 0 ;
43725
43726   arg1 = (Dali::Path *)jarg1;
43727   arg2 = (Dali::Vector3 *)jarg2;
43728   if (!arg2) {
43729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43730     return ;
43731   }
43732   {
43733     try {
43734       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43735     } catch (std::out_of_range& e) {
43736       {
43737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43738       };
43739     } catch (std::exception& e) {
43740       {
43741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43742       };
43743     } catch (Dali::DaliException e) {
43744       {
43745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43746       };
43747     } catch (...) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43750       };
43751     }
43752   }
43753
43754 }
43755
43756
43757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43758   Dali::Path *arg1 = (Dali::Path *) 0 ;
43759   float arg2 ;
43760
43761   arg1 = (Dali::Path *)jarg1;
43762   arg2 = (float)jarg2;
43763   {
43764     try {
43765       (arg1)->GenerateControlPoints(arg2);
43766     } catch (std::out_of_range& e) {
43767       {
43768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43769       };
43770     } catch (std::exception& e) {
43771       {
43772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43773       };
43774     } catch (Dali::DaliException e) {
43775       {
43776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43777       };
43778     } catch (...) {
43779       {
43780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43781       };
43782     }
43783   }
43784
43785 }
43786
43787
43788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43789   Dali::Path *arg1 = (Dali::Path *) 0 ;
43790   float arg2 ;
43791   Dali::Vector3 *arg3 = 0 ;
43792   Dali::Vector3 *arg4 = 0 ;
43793
43794   arg1 = (Dali::Path *)jarg1;
43795   arg2 = (float)jarg2;
43796   arg3 = (Dali::Vector3 *)jarg3;
43797   if (!arg3) {
43798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43799     return ;
43800   }
43801   arg4 = (Dali::Vector3 *)jarg4;
43802   if (!arg4) {
43803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43804     return ;
43805   }
43806   {
43807     try {
43808       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43809     } catch (std::out_of_range& e) {
43810       {
43811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43812       };
43813     } catch (std::exception& e) {
43814       {
43815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43816       };
43817     } catch (Dali::DaliException e) {
43818       {
43819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43820       };
43821     } catch (...) {
43822       {
43823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43824       };
43825     }
43826   }
43827
43828 }
43829
43830
43831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43832   void * jresult ;
43833   Dali::Path *arg1 = (Dali::Path *) 0 ;
43834   size_t arg2 ;
43835   Dali::Vector3 *result = 0 ;
43836
43837   arg1 = (Dali::Path *)jarg1;
43838   arg2 = (size_t)jarg2;
43839   {
43840     try {
43841       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43842     } catch (std::out_of_range& e) {
43843       {
43844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43845       };
43846     } catch (std::exception& e) {
43847       {
43848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43849       };
43850     } catch (Dali::DaliException e) {
43851       {
43852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43853       };
43854     } catch (...) {
43855       {
43856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43857       };
43858     }
43859   }
43860
43861   jresult = (void *)result;
43862   return jresult;
43863 }
43864
43865
43866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43867   void * jresult ;
43868   Dali::Path *arg1 = (Dali::Path *) 0 ;
43869   size_t arg2 ;
43870   Dali::Vector3 *result = 0 ;
43871
43872   arg1 = (Dali::Path *)jarg1;
43873   arg2 = (size_t)jarg2;
43874   {
43875     try {
43876       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43877     } catch (std::out_of_range& e) {
43878       {
43879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43880       };
43881     } catch (std::exception& e) {
43882       {
43883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43884       };
43885     } catch (Dali::DaliException e) {
43886       {
43887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43888       };
43889     } catch (...) {
43890       {
43891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43892       };
43893     }
43894   }
43895
43896   jresult = (void *)result;
43897   return jresult;
43898 }
43899
43900
43901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43902   unsigned long jresult ;
43903   Dali::Path *arg1 = (Dali::Path *) 0 ;
43904   size_t result;
43905
43906   arg1 = (Dali::Path *)jarg1;
43907   {
43908     try {
43909       result = ((Dali::Path const *)arg1)->GetPointCount();
43910     } catch (std::out_of_range& e) {
43911       {
43912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43913       };
43914     } catch (std::exception& e) {
43915       {
43916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43917       };
43918     } catch (Dali::DaliException e) {
43919       {
43920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43921       };
43922     } catch (...) {
43923       {
43924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43925       };
43926     }
43927   }
43928
43929   jresult = (unsigned long)result;
43930   return jresult;
43931 }
43932
43933
43934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43935   void * jresult ;
43936   float arg1 ;
43937   Dali::TimePeriod *result = 0 ;
43938
43939   arg1 = (float)jarg1;
43940   {
43941     try {
43942       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43943     } catch (std::out_of_range& e) {
43944       {
43945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (std::exception& e) {
43948       {
43949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43950       };
43951     } catch (Dali::DaliException e) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43954       };
43955     } catch (...) {
43956       {
43957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43958       };
43959     }
43960   }
43961
43962   jresult = (void *)result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43968   void * jresult ;
43969   float arg1 ;
43970   float arg2 ;
43971   Dali::TimePeriod *result = 0 ;
43972
43973   arg1 = (float)jarg1;
43974   arg2 = (float)jarg2;
43975   {
43976     try {
43977       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43978     } catch (std::out_of_range& e) {
43979       {
43980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43981       };
43982     } catch (std::exception& e) {
43983       {
43984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43985       };
43986     } catch (Dali::DaliException e) {
43987       {
43988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43989       };
43990     } catch (...) {
43991       {
43992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43993       };
43994     }
43995   }
43996
43997   jresult = (void *)result;
43998   return jresult;
43999 }
44000
44001
44002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44003   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44004
44005   arg1 = (Dali::TimePeriod *)jarg1;
44006   {
44007     try {
44008       delete arg1;
44009     } catch (std::out_of_range& e) {
44010       {
44011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44012       };
44013     } catch (std::exception& e) {
44014       {
44015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44016       };
44017     } catch (Dali::DaliException e) {
44018       {
44019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44020       };
44021     } catch (...) {
44022       {
44023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44024       };
44025     }
44026   }
44027
44028 }
44029
44030
44031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44032   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44033   float arg2 ;
44034
44035   arg1 = (Dali::TimePeriod *)jarg1;
44036   arg2 = (float)jarg2;
44037   if (arg1) (arg1)->delaySeconds = arg2;
44038 }
44039
44040
44041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44042   float jresult ;
44043   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44044   float result;
44045
44046   arg1 = (Dali::TimePeriod *)jarg1;
44047   result = (float) ((arg1)->delaySeconds);
44048   jresult = result;
44049   return jresult;
44050 }
44051
44052
44053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44054   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44055   float arg2 ;
44056
44057   arg1 = (Dali::TimePeriod *)jarg1;
44058   arg2 = (float)jarg2;
44059   if (arg1) (arg1)->durationSeconds = arg2;
44060 }
44061
44062
44063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44064   float jresult ;
44065   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44066   float result;
44067
44068   arg1 = (Dali::TimePeriod *)jarg1;
44069   result = (float) ((arg1)->durationSeconds);
44070   jresult = result;
44071   return jresult;
44072 }
44073
44074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44075   int jresult ;
44076   int result;
44077
44078   result = (int)Dali::LinearConstrainer::Property::VALUE;
44079   jresult = (int)result;
44080   return jresult;
44081 }
44082
44083
44084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44085   int jresult ;
44086   int result;
44087
44088   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44089   jresult = (int)result;
44090   return jresult;
44091 }
44092
44093
44094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44095   void * jresult ;
44096   Dali::LinearConstrainer::Property *result = 0 ;
44097
44098   {
44099     try {
44100       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44101     } catch (std::out_of_range& e) {
44102       {
44103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (std::exception& e) {
44106       {
44107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44108       };
44109     } catch (Dali::DaliException e) {
44110       {
44111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44112       };
44113     } catch (...) {
44114       {
44115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44116       };
44117     }
44118   }
44119
44120   jresult = (void *)result;
44121   return jresult;
44122 }
44123
44124
44125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44126   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44127
44128   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44129   {
44130     try {
44131       delete arg1;
44132     } catch (std::out_of_range& e) {
44133       {
44134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44135       };
44136     } catch (std::exception& e) {
44137       {
44138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44139       };
44140     } catch (Dali::DaliException e) {
44141       {
44142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44143       };
44144     } catch (...) {
44145       {
44146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44147       };
44148     }
44149   }
44150
44151 }
44152
44153
44154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44155   void * jresult ;
44156   Dali::LinearConstrainer result;
44157
44158   {
44159     try {
44160       result = Dali::LinearConstrainer::New();
44161     } catch (std::out_of_range& e) {
44162       {
44163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44164       };
44165     } catch (std::exception& e) {
44166       {
44167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44168       };
44169     } catch (Dali::DaliException e) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44172       };
44173     } catch (...) {
44174       {
44175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44176       };
44177     }
44178   }
44179
44180   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44181   return jresult;
44182 }
44183
44184
44185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44186   void * jresult ;
44187   Dali::BaseHandle arg1 ;
44188   Dali::BaseHandle *argp1 ;
44189   Dali::LinearConstrainer result;
44190
44191   argp1 = (Dali::BaseHandle *)jarg1;
44192   if (!argp1) {
44193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44194     return 0;
44195   }
44196   arg1 = *argp1;
44197   {
44198     try {
44199       result = Dali::LinearConstrainer::DownCast(arg1);
44200     } catch (std::out_of_range& e) {
44201       {
44202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44203       };
44204     } catch (std::exception& e) {
44205       {
44206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44207       };
44208     } catch (Dali::DaliException e) {
44209       {
44210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44211       };
44212     } catch (...) {
44213       {
44214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44215       };
44216     }
44217   }
44218
44219   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44220   return jresult;
44221 }
44222
44223
44224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44225   void * jresult ;
44226   Dali::LinearConstrainer *result = 0 ;
44227
44228   {
44229     try {
44230       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44231     } catch (std::out_of_range& e) {
44232       {
44233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44234       };
44235     } catch (std::exception& e) {
44236       {
44237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44238       };
44239     } catch (Dali::DaliException e) {
44240       {
44241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44242       };
44243     } catch (...) {
44244       {
44245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44246       };
44247     }
44248   }
44249
44250   jresult = (void *)result;
44251   return jresult;
44252 }
44253
44254
44255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44256   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44257
44258   arg1 = (Dali::LinearConstrainer *)jarg1;
44259   {
44260     try {
44261       delete arg1;
44262     } catch (std::out_of_range& e) {
44263       {
44264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44265       };
44266     } catch (std::exception& e) {
44267       {
44268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44269       };
44270     } catch (Dali::DaliException e) {
44271       {
44272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44273       };
44274     } catch (...) {
44275       {
44276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44277       };
44278     }
44279   }
44280
44281 }
44282
44283
44284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44285   void * jresult ;
44286   Dali::LinearConstrainer *arg1 = 0 ;
44287   Dali::LinearConstrainer *result = 0 ;
44288
44289   arg1 = (Dali::LinearConstrainer *)jarg1;
44290   if (!arg1) {
44291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44292     return 0;
44293   }
44294   {
44295     try {
44296       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44312       };
44313     }
44314   }
44315
44316   jresult = (void *)result;
44317   return jresult;
44318 }
44319
44320
44321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44322   void * jresult ;
44323   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44324   Dali::LinearConstrainer *arg2 = 0 ;
44325   Dali::LinearConstrainer *result = 0 ;
44326
44327   arg1 = (Dali::LinearConstrainer *)jarg1;
44328   arg2 = (Dali::LinearConstrainer *)jarg2;
44329   if (!arg2) {
44330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44331     return 0;
44332   }
44333   {
44334     try {
44335       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44336     } catch (std::out_of_range& e) {
44337       {
44338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44339       };
44340     } catch (std::exception& e) {
44341       {
44342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44343       };
44344     } catch (Dali::DaliException e) {
44345       {
44346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44347       };
44348     } catch (...) {
44349       {
44350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44351       };
44352     }
44353   }
44354
44355   jresult = (void *)result;
44356   return jresult;
44357 }
44358
44359
44360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44361   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44362   SwigValueWrapper< Dali::Property > arg2 ;
44363   SwigValueWrapper< Dali::Property > arg3 ;
44364   Dali::Vector2 *arg4 = 0 ;
44365   Dali::Vector2 *arg5 = 0 ;
44366   Dali::Property *argp2 ;
44367   Dali::Property *argp3 ;
44368
44369   arg1 = (Dali::LinearConstrainer *)jarg1;
44370   argp2 = (Dali::Property *)jarg2;
44371   if (!argp2) {
44372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44373     return ;
44374   }
44375   arg2 = *argp2;
44376   argp3 = (Dali::Property *)jarg3;
44377   if (!argp3) {
44378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44379     return ;
44380   }
44381   arg3 = *argp3;
44382   arg4 = (Dali::Vector2 *)jarg4;
44383   if (!arg4) {
44384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44385     return ;
44386   }
44387   arg5 = (Dali::Vector2 *)jarg5;
44388   if (!arg5) {
44389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44390     return ;
44391   }
44392   {
44393     try {
44394       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44395     } catch (std::out_of_range& e) {
44396       {
44397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44398       };
44399     } catch (std::exception& e) {
44400       {
44401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44402       };
44403     } catch (Dali::DaliException e) {
44404       {
44405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44406       };
44407     } catch (...) {
44408       {
44409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44410       };
44411     }
44412   }
44413
44414 }
44415
44416
44417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44418   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44419   SwigValueWrapper< Dali::Property > arg2 ;
44420   SwigValueWrapper< Dali::Property > arg3 ;
44421   Dali::Vector2 *arg4 = 0 ;
44422   Dali::Property *argp2 ;
44423   Dali::Property *argp3 ;
44424
44425   arg1 = (Dali::LinearConstrainer *)jarg1;
44426   argp2 = (Dali::Property *)jarg2;
44427   if (!argp2) {
44428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44429     return ;
44430   }
44431   arg2 = *argp2;
44432   argp3 = (Dali::Property *)jarg3;
44433   if (!argp3) {
44434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44435     return ;
44436   }
44437   arg3 = *argp3;
44438   arg4 = (Dali::Vector2 *)jarg4;
44439   if (!arg4) {
44440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44441     return ;
44442   }
44443   {
44444     try {
44445       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44446     } catch (std::out_of_range& e) {
44447       {
44448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44449       };
44450     } catch (std::exception& e) {
44451       {
44452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44453       };
44454     } catch (Dali::DaliException e) {
44455       {
44456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44457       };
44458     } catch (...) {
44459       {
44460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44461       };
44462     }
44463   }
44464
44465 }
44466
44467
44468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44469   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44470   Dali::Handle *arg2 = 0 ;
44471
44472   arg1 = (Dali::LinearConstrainer *)jarg1;
44473   arg2 = (Dali::Handle *)jarg2;
44474   if (!arg2) {
44475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44476     return ;
44477   }
44478   {
44479     try {
44480       (arg1)->Remove(*arg2);
44481     } catch (std::out_of_range& e) {
44482       {
44483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44484       };
44485     } catch (std::exception& e) {
44486       {
44487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44488       };
44489     } catch (Dali::DaliException e) {
44490       {
44491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44492       };
44493     } catch (...) {
44494       {
44495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44496       };
44497     }
44498   }
44499
44500 }
44501
44502
44503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44504   int jresult ;
44505   int result;
44506
44507   result = (int)Dali::PathConstrainer::Property::FORWARD;
44508   jresult = (int)result;
44509   return jresult;
44510 }
44511
44512
44513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44514   int jresult ;
44515   int result;
44516
44517   result = (int)Dali::PathConstrainer::Property::POINTS;
44518   jresult = (int)result;
44519   return jresult;
44520 }
44521
44522
44523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44524   int jresult ;
44525   int result;
44526
44527   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44528   jresult = (int)result;
44529   return jresult;
44530 }
44531
44532
44533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44534   void * jresult ;
44535   Dali::PathConstrainer::Property *result = 0 ;
44536
44537   {
44538     try {
44539       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44540     } catch (std::out_of_range& e) {
44541       {
44542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44543       };
44544     } catch (std::exception& e) {
44545       {
44546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44547       };
44548     } catch (Dali::DaliException e) {
44549       {
44550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44551       };
44552     } catch (...) {
44553       {
44554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44555       };
44556     }
44557   }
44558
44559   jresult = (void *)result;
44560   return jresult;
44561 }
44562
44563
44564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44565   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44566
44567   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44568   {
44569     try {
44570       delete arg1;
44571     } catch (std::out_of_range& e) {
44572       {
44573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44574       };
44575     } catch (std::exception& e) {
44576       {
44577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44578       };
44579     } catch (Dali::DaliException e) {
44580       {
44581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44582       };
44583     } catch (...) {
44584       {
44585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44586       };
44587     }
44588   }
44589
44590 }
44591
44592
44593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44594   void * jresult ;
44595   Dali::PathConstrainer result;
44596
44597   {
44598     try {
44599       result = Dali::PathConstrainer::New();
44600     } catch (std::out_of_range& e) {
44601       {
44602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44603       };
44604     } catch (std::exception& e) {
44605       {
44606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44607       };
44608     } catch (Dali::DaliException e) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44611       };
44612     } catch (...) {
44613       {
44614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44615       };
44616     }
44617   }
44618
44619   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44620   return jresult;
44621 }
44622
44623
44624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44625   void * jresult ;
44626   Dali::BaseHandle arg1 ;
44627   Dali::BaseHandle *argp1 ;
44628   Dali::PathConstrainer result;
44629
44630   argp1 = (Dali::BaseHandle *)jarg1;
44631   if (!argp1) {
44632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44633     return 0;
44634   }
44635   arg1 = *argp1;
44636   {
44637     try {
44638       result = Dali::PathConstrainer::DownCast(arg1);
44639     } catch (std::out_of_range& e) {
44640       {
44641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44642       };
44643     } catch (std::exception& e) {
44644       {
44645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44646       };
44647     } catch (Dali::DaliException e) {
44648       {
44649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44650       };
44651     } catch (...) {
44652       {
44653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44654       };
44655     }
44656   }
44657
44658   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44659   return jresult;
44660 }
44661
44662
44663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44664   void * jresult ;
44665   Dali::PathConstrainer *result = 0 ;
44666
44667   {
44668     try {
44669       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44670     } catch (std::out_of_range& e) {
44671       {
44672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44673       };
44674     } catch (std::exception& e) {
44675       {
44676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44677       };
44678     } catch (Dali::DaliException e) {
44679       {
44680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44681       };
44682     } catch (...) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44685       };
44686     }
44687   }
44688
44689   jresult = (void *)result;
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44695   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44696
44697   arg1 = (Dali::PathConstrainer *)jarg1;
44698   {
44699     try {
44700       delete arg1;
44701     } catch (std::out_of_range& e) {
44702       {
44703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44704       };
44705     } catch (std::exception& e) {
44706       {
44707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44708       };
44709     } catch (Dali::DaliException e) {
44710       {
44711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44712       };
44713     } catch (...) {
44714       {
44715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44716       };
44717     }
44718   }
44719
44720 }
44721
44722
44723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44724   void * jresult ;
44725   Dali::PathConstrainer *arg1 = 0 ;
44726   Dali::PathConstrainer *result = 0 ;
44727
44728   arg1 = (Dali::PathConstrainer *)jarg1;
44729   if (!arg1) {
44730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44731     return 0;
44732   }
44733   {
44734     try {
44735       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44736     } catch (std::out_of_range& e) {
44737       {
44738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44739       };
44740     } catch (std::exception& e) {
44741       {
44742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44743       };
44744     } catch (Dali::DaliException e) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44747       };
44748     } catch (...) {
44749       {
44750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44751       };
44752     }
44753   }
44754
44755   jresult = (void *)result;
44756   return jresult;
44757 }
44758
44759
44760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44761   void * jresult ;
44762   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44763   Dali::PathConstrainer *arg2 = 0 ;
44764   Dali::PathConstrainer *result = 0 ;
44765
44766   arg1 = (Dali::PathConstrainer *)jarg1;
44767   arg2 = (Dali::PathConstrainer *)jarg2;
44768   if (!arg2) {
44769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44770     return 0;
44771   }
44772   {
44773     try {
44774       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44775     } catch (std::out_of_range& e) {
44776       {
44777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44778       };
44779     } catch (std::exception& e) {
44780       {
44781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44782       };
44783     } catch (Dali::DaliException e) {
44784       {
44785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44786       };
44787     } catch (...) {
44788       {
44789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44790       };
44791     }
44792   }
44793
44794   jresult = (void *)result;
44795   return jresult;
44796 }
44797
44798
44799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44800   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44801   SwigValueWrapper< Dali::Property > arg2 ;
44802   SwigValueWrapper< Dali::Property > arg3 ;
44803   Dali::Vector2 *arg4 = 0 ;
44804   Dali::Vector2 *arg5 = 0 ;
44805   Dali::Property *argp2 ;
44806   Dali::Property *argp3 ;
44807
44808   arg1 = (Dali::PathConstrainer *)jarg1;
44809   argp2 = (Dali::Property *)jarg2;
44810   if (!argp2) {
44811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44812     return ;
44813   }
44814   arg2 = *argp2;
44815   argp3 = (Dali::Property *)jarg3;
44816   if (!argp3) {
44817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44818     return ;
44819   }
44820   arg3 = *argp3;
44821   arg4 = (Dali::Vector2 *)jarg4;
44822   if (!arg4) {
44823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44824     return ;
44825   }
44826   arg5 = (Dali::Vector2 *)jarg5;
44827   if (!arg5) {
44828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44829     return ;
44830   }
44831   {
44832     try {
44833       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44834     } catch (std::out_of_range& e) {
44835       {
44836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44837       };
44838     } catch (std::exception& e) {
44839       {
44840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44841       };
44842     } catch (Dali::DaliException e) {
44843       {
44844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44845       };
44846     } catch (...) {
44847       {
44848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44849       };
44850     }
44851   }
44852
44853 }
44854
44855
44856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44857   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44858   SwigValueWrapper< Dali::Property > arg2 ;
44859   SwigValueWrapper< Dali::Property > arg3 ;
44860   Dali::Vector2 *arg4 = 0 ;
44861   Dali::Property *argp2 ;
44862   Dali::Property *argp3 ;
44863
44864   arg1 = (Dali::PathConstrainer *)jarg1;
44865   argp2 = (Dali::Property *)jarg2;
44866   if (!argp2) {
44867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44868     return ;
44869   }
44870   arg2 = *argp2;
44871   argp3 = (Dali::Property *)jarg3;
44872   if (!argp3) {
44873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44874     return ;
44875   }
44876   arg3 = *argp3;
44877   arg4 = (Dali::Vector2 *)jarg4;
44878   if (!arg4) {
44879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44880     return ;
44881   }
44882   {
44883     try {
44884       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44885     } catch (std::out_of_range& e) {
44886       {
44887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44888       };
44889     } catch (std::exception& e) {
44890       {
44891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44892       };
44893     } catch (Dali::DaliException e) {
44894       {
44895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44896       };
44897     } catch (...) {
44898       {
44899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44900       };
44901     }
44902   }
44903
44904 }
44905
44906
44907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44908   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44909   Dali::Handle *arg2 = 0 ;
44910
44911   arg1 = (Dali::PathConstrainer *)jarg1;
44912   arg2 = (Dali::Handle *)jarg2;
44913   if (!arg2) {
44914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44915     return ;
44916   }
44917   {
44918     try {
44919       (arg1)->Remove(*arg2);
44920     } catch (std::out_of_range& e) {
44921       {
44922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44923       };
44924     } catch (std::exception& e) {
44925       {
44926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44927       };
44928     } catch (Dali::DaliException e) {
44929       {
44930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44931       };
44932     } catch (...) {
44933       {
44934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44935       };
44936     }
44937   }
44938
44939 }
44940
44941
44942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44943   int jresult ;
44944   Dali::FittingMode::Type result;
44945
44946   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44947   jresult = (int)result;
44948   return jresult;
44949 }
44950
44951
44952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44953   int jresult ;
44954   Dali::SamplingMode::Type result;
44955
44956   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44957   jresult = (int)result;
44958   return jresult;
44959 }
44960
44961
44962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44963   void * jresult ;
44964   Dali::BufferImage *result = 0 ;
44965
44966   {
44967     try {
44968       result = (Dali::BufferImage *)new Dali::BufferImage();
44969     } catch (std::out_of_range& e) {
44970       {
44971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44972       };
44973     } catch (std::exception& e) {
44974       {
44975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44976       };
44977     } catch (Dali::DaliException e) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44980       };
44981     } catch (...) {
44982       {
44983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44984       };
44985     }
44986   }
44987
44988   jresult = (void *)result;
44989   return jresult;
44990 }
44991
44992
44993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
44994   void * jresult ;
44995   unsigned int arg1 ;
44996   unsigned int arg2 ;
44997   Dali::Pixel::Format arg3 ;
44998   Dali::BufferImage result;
44999
45000   arg1 = (unsigned int)jarg1;
45001   arg2 = (unsigned int)jarg2;
45002   arg3 = (Dali::Pixel::Format)jarg3;
45003   {
45004     try {
45005       result = Dali::BufferImage::New(arg1,arg2,arg3);
45006     } catch (std::out_of_range& e) {
45007       {
45008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45009       };
45010     } catch (std::exception& e) {
45011       {
45012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45013       };
45014     } catch (Dali::DaliException e) {
45015       {
45016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45017       };
45018     } catch (...) {
45019       {
45020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45021       };
45022     }
45023   }
45024
45025   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45026   return jresult;
45027 }
45028
45029
45030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45031   void * jresult ;
45032   unsigned int arg1 ;
45033   unsigned int arg2 ;
45034   Dali::BufferImage result;
45035
45036   arg1 = (unsigned int)jarg1;
45037   arg2 = (unsigned int)jarg2;
45038   {
45039     try {
45040       result = Dali::BufferImage::New(arg1,arg2);
45041     } catch (std::out_of_range& e) {
45042       {
45043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45044       };
45045     } catch (std::exception& e) {
45046       {
45047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45048       };
45049     } catch (Dali::DaliException e) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45056       };
45057     }
45058   }
45059
45060   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45061   return jresult;
45062 }
45063
45064
45065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45066   void * jresult ;
45067   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45068   unsigned int arg2 ;
45069   unsigned int arg3 ;
45070   Dali::Pixel::Format arg4 ;
45071   unsigned int arg5 ;
45072   Dali::BufferImage result;
45073
45074   arg1 = jarg1;
45075   arg2 = (unsigned int)jarg2;
45076   arg3 = (unsigned int)jarg3;
45077   arg4 = (Dali::Pixel::Format)jarg4;
45078   arg5 = (unsigned int)jarg5;
45079   {
45080     try {
45081       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (Dali::DaliException e) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45093       };
45094     } catch (...) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45097       };
45098     }
45099   }
45100
45101   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45102
45103
45104   return jresult;
45105 }
45106
45107
45108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45109   void * jresult ;
45110   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45111   unsigned int arg2 ;
45112   unsigned int arg3 ;
45113   Dali::Pixel::Format arg4 ;
45114   Dali::BufferImage result;
45115
45116   arg1 = jarg1;
45117   arg2 = (unsigned int)jarg2;
45118   arg3 = (unsigned int)jarg3;
45119   arg4 = (Dali::Pixel::Format)jarg4;
45120   {
45121     try {
45122       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45123     } catch (std::out_of_range& e) {
45124       {
45125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45126       };
45127     } catch (std::exception& e) {
45128       {
45129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (Dali::DaliException e) {
45132       {
45133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141
45142   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45143
45144
45145   return jresult;
45146 }
45147
45148
45149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45150   void * jresult ;
45151   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45152   unsigned int arg2 ;
45153   unsigned int arg3 ;
45154   Dali::BufferImage result;
45155
45156   arg1 = jarg1;
45157   arg2 = (unsigned int)jarg2;
45158   arg3 = (unsigned int)jarg3;
45159   {
45160     try {
45161       result = Dali::BufferImage::New(arg1,arg2,arg3);
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45182
45183
45184   return jresult;
45185 }
45186
45187
45188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45189   void * jresult ;
45190   Dali::BaseHandle arg1 ;
45191   Dali::BaseHandle *argp1 ;
45192   Dali::BufferImage result;
45193
45194   argp1 = (Dali::BaseHandle *)jarg1;
45195   if (!argp1) {
45196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45197     return 0;
45198   }
45199   arg1 = *argp1;
45200   {
45201     try {
45202       result = Dali::BufferImage::DownCast(arg1);
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45210       };
45211     } catch (Dali::DaliException e) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45214       };
45215     } catch (...) {
45216       {
45217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45218       };
45219     }
45220   }
45221
45222   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45223   return jresult;
45224 }
45225
45226
45227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45228   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45229
45230   arg1 = (Dali::BufferImage *)jarg1;
45231   {
45232     try {
45233       delete arg1;
45234     } catch (std::out_of_range& e) {
45235       {
45236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45237       };
45238     } catch (std::exception& e) {
45239       {
45240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45241       };
45242     } catch (Dali::DaliException e) {
45243       {
45244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45245       };
45246     } catch (...) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45249       };
45250     }
45251   }
45252
45253 }
45254
45255
45256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45257   void * jresult ;
45258   Dali::BufferImage *arg1 = 0 ;
45259   Dali::BufferImage *result = 0 ;
45260
45261   arg1 = (Dali::BufferImage *)jarg1;
45262   if (!arg1) {
45263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45264     return 0;
45265   }
45266   {
45267     try {
45268       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45269     } catch (std::out_of_range& e) {
45270       {
45271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45272       };
45273     } catch (std::exception& e) {
45274       {
45275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45276       };
45277     } catch (Dali::DaliException e) {
45278       {
45279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45280       };
45281     } catch (...) {
45282       {
45283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45284       };
45285     }
45286   }
45287
45288   jresult = (void *)result;
45289   return jresult;
45290 }
45291
45292
45293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45294   void * jresult ;
45295   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45296   Dali::BufferImage *arg2 = 0 ;
45297   Dali::BufferImage *result = 0 ;
45298
45299   arg1 = (Dali::BufferImage *)jarg1;
45300   arg2 = (Dali::BufferImage *)jarg2;
45301   if (!arg2) {
45302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45303     return 0;
45304   }
45305   {
45306     try {
45307       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45308     } catch (std::out_of_range& e) {
45309       {
45310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45311       };
45312     } catch (std::exception& e) {
45313       {
45314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45315       };
45316     } catch (Dali::DaliException e) {
45317       {
45318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45319       };
45320     } catch (...) {
45321       {
45322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45323       };
45324     }
45325   }
45326
45327   jresult = (void *)result;
45328   return jresult;
45329 }
45330
45331
45332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45333   void * jresult ;
45334   Dali::BufferImage result;
45335
45336   {
45337     try {
45338       result = Dali::BufferImage::WHITE();
45339     } catch (std::out_of_range& e) {
45340       {
45341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45342       };
45343     } catch (std::exception& e) {
45344       {
45345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45346       };
45347     } catch (Dali::DaliException e) {
45348       {
45349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45350       };
45351     } catch (...) {
45352       {
45353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45354       };
45355     }
45356   }
45357
45358   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45359   return jresult;
45360 }
45361
45362
45363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45364   void * jresult ;
45365   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45366   Dali::PixelBuffer *result = 0 ;
45367
45368   arg1 = (Dali::BufferImage *)jarg1;
45369   {
45370     try {
45371       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45372     } catch (std::out_of_range& e) {
45373       {
45374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45375       };
45376     } catch (std::exception& e) {
45377       {
45378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45379       };
45380     } catch (Dali::DaliException e) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45383       };
45384     } catch (...) {
45385       {
45386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45387       };
45388     }
45389   }
45390
45391   jresult = (void *)result;
45392   return jresult;
45393 }
45394
45395
45396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45397   unsigned int jresult ;
45398   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45399   unsigned int result;
45400
45401   arg1 = (Dali::BufferImage *)jarg1;
45402   {
45403     try {
45404       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45405     } catch (std::out_of_range& e) {
45406       {
45407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (std::exception& e) {
45410       {
45411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45412       };
45413     } catch (Dali::DaliException e) {
45414       {
45415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45416       };
45417     } catch (...) {
45418       {
45419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45420       };
45421     }
45422   }
45423
45424   jresult = result;
45425   return jresult;
45426 }
45427
45428
45429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45430   unsigned int jresult ;
45431   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45432   unsigned int result;
45433
45434   arg1 = (Dali::BufferImage *)jarg1;
45435   {
45436     try {
45437       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45438     } catch (std::out_of_range& e) {
45439       {
45440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (std::exception& e) {
45443       {
45444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45445       };
45446     } catch (Dali::DaliException e) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45449       };
45450     } catch (...) {
45451       {
45452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45453       };
45454     }
45455   }
45456
45457   jresult = result;
45458   return jresult;
45459 }
45460
45461
45462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45463   int jresult ;
45464   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45465   Dali::Pixel::Format result;
45466
45467   arg1 = (Dali::BufferImage *)jarg1;
45468   {
45469     try {
45470       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45471     } catch (std::out_of_range& e) {
45472       {
45473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (std::exception& e) {
45476       {
45477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45478       };
45479     } catch (Dali::DaliException e) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45482       };
45483     } catch (...) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45486       };
45487     }
45488   }
45489
45490   jresult = (int)result;
45491   return jresult;
45492 }
45493
45494
45495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45496   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45497
45498   arg1 = (Dali::BufferImage *)jarg1;
45499   {
45500     try {
45501       (arg1)->Update();
45502     } catch (std::out_of_range& e) {
45503       {
45504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45505       };
45506     } catch (std::exception& e) {
45507       {
45508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45509       };
45510     } catch (Dali::DaliException e) {
45511       {
45512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45513       };
45514     } catch (...) {
45515       {
45516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45517       };
45518     }
45519   }
45520
45521 }
45522
45523
45524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45525   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45526   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45527   Dali::RectArea *argp2 ;
45528
45529   arg1 = (Dali::BufferImage *)jarg1;
45530   argp2 = (Dali::RectArea *)jarg2;
45531   if (!argp2) {
45532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45533     return ;
45534   }
45535   arg2 = *argp2;
45536   {
45537     try {
45538       (arg1)->Update(arg2);
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (Dali::DaliException e) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45550       };
45551     } catch (...) {
45552       {
45553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45554       };
45555     }
45556   }
45557
45558 }
45559
45560
45561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45562   unsigned int jresult ;
45563   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45564   bool result;
45565
45566   arg1 = (Dali::BufferImage *)jarg1;
45567   {
45568     try {
45569       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45570     } catch (std::out_of_range& e) {
45571       {
45572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45573       };
45574     } catch (std::exception& e) {
45575       {
45576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (Dali::DaliException e) {
45579       {
45580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45585       };
45586     }
45587   }
45588
45589   jresult = result;
45590   return jresult;
45591 }
45592
45593
45594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45595   void * jresult ;
45596   Dali::EncodedBufferImage *result = 0 ;
45597
45598   {
45599     try {
45600       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45601     } catch (std::out_of_range& e) {
45602       {
45603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45604       };
45605     } catch (std::exception& e) {
45606       {
45607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45608       };
45609     } catch (Dali::DaliException e) {
45610       {
45611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45612       };
45613     } catch (...) {
45614       {
45615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45616       };
45617     }
45618   }
45619
45620   jresult = (void *)result;
45621   return jresult;
45622 }
45623
45624
45625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45626   void * jresult ;
45627   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45628   std::size_t arg2 ;
45629   Dali::EncodedBufferImage result;
45630
45631   arg1 = (uint8_t *)jarg1;
45632   arg2 = (std::size_t)jarg2;
45633   {
45634     try {
45635       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45636     } catch (std::out_of_range& e) {
45637       {
45638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (std::exception& e) {
45641       {
45642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45643       };
45644     } catch (Dali::DaliException e) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45647       };
45648     } catch (...) {
45649       {
45650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45651       };
45652     }
45653   }
45654
45655   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45656   return jresult;
45657 }
45658
45659
45660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45661   void * jresult ;
45662   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45663   std::size_t arg2 ;
45664   Dali::ImageDimensions arg3 ;
45665   Dali::FittingMode::Type arg4 ;
45666   Dali::SamplingMode::Type arg5 ;
45667   bool arg6 ;
45668   Dali::ImageDimensions *argp3 ;
45669   Dali::EncodedBufferImage result;
45670
45671   arg1 = (uint8_t *)jarg1;
45672   arg2 = (std::size_t)jarg2;
45673   argp3 = (Dali::ImageDimensions *)jarg3;
45674   if (!argp3) {
45675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45676     return 0;
45677   }
45678   arg3 = *argp3;
45679   arg4 = (Dali::FittingMode::Type)jarg4;
45680   arg5 = (Dali::SamplingMode::Type)jarg5;
45681   arg6 = jarg6 ? true : false;
45682   {
45683     try {
45684       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45685     } catch (std::out_of_range& e) {
45686       {
45687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (std::exception& e) {
45690       {
45691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (Dali::DaliException e) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45696       };
45697     } catch (...) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45700       };
45701     }
45702   }
45703
45704   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45705   return jresult;
45706 }
45707
45708
45709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45710   void * jresult ;
45711   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45712   std::size_t arg2 ;
45713   Dali::ImageDimensions arg3 ;
45714   Dali::FittingMode::Type arg4 ;
45715   Dali::SamplingMode::Type arg5 ;
45716   Dali::ImageDimensions *argp3 ;
45717   Dali::EncodedBufferImage result;
45718
45719   arg1 = (uint8_t *)jarg1;
45720   arg2 = (std::size_t)jarg2;
45721   argp3 = (Dali::ImageDimensions *)jarg3;
45722   if (!argp3) {
45723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45724     return 0;
45725   }
45726   arg3 = *argp3;
45727   arg4 = (Dali::FittingMode::Type)jarg4;
45728   arg5 = (Dali::SamplingMode::Type)jarg5;
45729   {
45730     try {
45731       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45732     } catch (std::out_of_range& e) {
45733       {
45734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45735       };
45736     } catch (std::exception& e) {
45737       {
45738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45739       };
45740     } catch (Dali::DaliException e) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45743       };
45744     } catch (...) {
45745       {
45746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45747       };
45748     }
45749   }
45750
45751   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45752   return jresult;
45753 }
45754
45755
45756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45757   void * jresult ;
45758   Dali::BaseHandle arg1 ;
45759   Dali::BaseHandle *argp1 ;
45760   Dali::EncodedBufferImage result;
45761
45762   argp1 = (Dali::BaseHandle *)jarg1;
45763   if (!argp1) {
45764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45765     return 0;
45766   }
45767   arg1 = *argp1;
45768   {
45769     try {
45770       result = Dali::EncodedBufferImage::DownCast(arg1);
45771     } catch (std::out_of_range& e) {
45772       {
45773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45774       };
45775     } catch (std::exception& e) {
45776       {
45777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45778       };
45779     } catch (Dali::DaliException e) {
45780       {
45781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45782       };
45783     } catch (...) {
45784       {
45785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45786       };
45787     }
45788   }
45789
45790   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45791   return jresult;
45792 }
45793
45794
45795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45796   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45797
45798   arg1 = (Dali::EncodedBufferImage *)jarg1;
45799   {
45800     try {
45801       delete arg1;
45802     } catch (std::out_of_range& e) {
45803       {
45804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45805       };
45806     } catch (std::exception& e) {
45807       {
45808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45809       };
45810     } catch (Dali::DaliException e) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45813       };
45814     } catch (...) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45817       };
45818     }
45819   }
45820
45821 }
45822
45823
45824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45825   void * jresult ;
45826   Dali::EncodedBufferImage *arg1 = 0 ;
45827   Dali::EncodedBufferImage *result = 0 ;
45828
45829   arg1 = (Dali::EncodedBufferImage *)jarg1;
45830   if (!arg1) {
45831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45832     return 0;
45833   }
45834   {
45835     try {
45836       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45837     } catch (std::out_of_range& e) {
45838       {
45839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45840       };
45841     } catch (std::exception& e) {
45842       {
45843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (Dali::DaliException e) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45848       };
45849     } catch (...) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45852       };
45853     }
45854   }
45855
45856   jresult = (void *)result;
45857   return jresult;
45858 }
45859
45860
45861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45862   void * jresult ;
45863   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45864   Dali::EncodedBufferImage *arg2 = 0 ;
45865   Dali::EncodedBufferImage *result = 0 ;
45866
45867   arg1 = (Dali::EncodedBufferImage *)jarg1;
45868   arg2 = (Dali::EncodedBufferImage *)jarg2;
45869   if (!arg2) {
45870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45871     return 0;
45872   }
45873   {
45874     try {
45875       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45876     } catch (std::out_of_range& e) {
45877       {
45878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45879       };
45880     } catch (std::exception& e) {
45881       {
45882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45883       };
45884     } catch (Dali::DaliException e) {
45885       {
45886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45887       };
45888     } catch (...) {
45889       {
45890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45891       };
45892     }
45893   }
45894
45895   jresult = (void *)result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45901   void * jresult ;
45902   Dali::NativeImage *result = 0 ;
45903
45904   {
45905     try {
45906       result = (Dali::NativeImage *)new Dali::NativeImage();
45907     } catch (std::out_of_range& e) {
45908       {
45909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45910       };
45911     } catch (std::exception& e) {
45912       {
45913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45914       };
45915     } catch (Dali::DaliException e) {
45916       {
45917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45918       };
45919     } catch (...) {
45920       {
45921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45922       };
45923     }
45924   }
45925
45926   jresult = (void *)result;
45927   return jresult;
45928 }
45929
45930
45931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45932   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45933
45934   arg1 = (Dali::NativeImage *)jarg1;
45935   {
45936     try {
45937       delete arg1;
45938     } catch (std::out_of_range& e) {
45939       {
45940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45941       };
45942     } catch (std::exception& e) {
45943       {
45944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45945       };
45946     } catch (Dali::DaliException e) {
45947       {
45948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45949       };
45950     } catch (...) {
45951       {
45952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45953       };
45954     }
45955   }
45956
45957 }
45958
45959
45960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45961   void * jresult ;
45962   Dali::NativeImage *arg1 = 0 ;
45963   Dali::NativeImage *result = 0 ;
45964
45965   arg1 = (Dali::NativeImage *)jarg1;
45966   if (!arg1) {
45967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45968     return 0;
45969   }
45970   {
45971     try {
45972       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45980       };
45981     } catch (Dali::DaliException e) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45984       };
45985     } catch (...) {
45986       {
45987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45988       };
45989     }
45990   }
45991
45992   jresult = (void *)result;
45993   return jresult;
45994 }
45995
45996
45997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45998   void * jresult ;
45999   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46000   Dali::NativeImage *arg2 = 0 ;
46001   Dali::NativeImage *result = 0 ;
46002
46003   arg1 = (Dali::NativeImage *)jarg1;
46004   arg2 = (Dali::NativeImage *)jarg2;
46005   if (!arg2) {
46006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46007     return 0;
46008   }
46009   {
46010     try {
46011       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46012     } catch (std::out_of_range& e) {
46013       {
46014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46015       };
46016     } catch (std::exception& e) {
46017       {
46018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46019       };
46020     } catch (Dali::DaliException e) {
46021       {
46022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46023       };
46024     } catch (...) {
46025       {
46026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46027       };
46028     }
46029   }
46030
46031   jresult = (void *)result;
46032   return jresult;
46033 }
46034
46035
46036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46037   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46038
46039   arg1 = (Dali::NativeImage *)jarg1;
46040   {
46041     try {
46042       (arg1)->CreateGlTexture();
46043     } catch (std::out_of_range& e) {
46044       {
46045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46046       };
46047     } catch (std::exception& e) {
46048       {
46049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46050       };
46051     } catch (Dali::DaliException e) {
46052       {
46053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46054       };
46055     } catch (...) {
46056       {
46057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46058       };
46059     }
46060   }
46061
46062 }
46063
46064
46065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46066   void * jresult ;
46067   NativeImageInterface *arg1 = 0 ;
46068   Dali::NativeImage result;
46069
46070   arg1 = (NativeImageInterface *)jarg1;
46071   if (!arg1) {
46072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46073     return 0;
46074   }
46075   {
46076     try {
46077       result = Dali::NativeImage::New(*arg1);
46078     } catch (std::out_of_range& e) {
46079       {
46080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46081       };
46082     } catch (std::exception& e) {
46083       {
46084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46085       };
46086     } catch (Dali::DaliException e) {
46087       {
46088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46089       };
46090     } catch (...) {
46091       {
46092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46093       };
46094     }
46095   }
46096
46097   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46098   return jresult;
46099 }
46100
46101
46102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46103   void * jresult ;
46104   Dali::BaseHandle arg1 ;
46105   Dali::BaseHandle *argp1 ;
46106   Dali::NativeImage result;
46107
46108   argp1 = (Dali::BaseHandle *)jarg1;
46109   if (!argp1) {
46110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46111     return 0;
46112   }
46113   arg1 = *argp1;
46114   {
46115     try {
46116       result = Dali::NativeImage::DownCast(arg1);
46117     } catch (std::out_of_range& e) {
46118       {
46119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46120       };
46121     } catch (std::exception& e) {
46122       {
46123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46124       };
46125     } catch (Dali::DaliException e) {
46126       {
46127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46128       };
46129     } catch (...) {
46130       {
46131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46132       };
46133     }
46134   }
46135
46136   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46137   return jresult;
46138 }
46139
46140
46141 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46142   char * jresult ;
46143   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46144   char *result = 0 ;
46145
46146   arg1 = (Dali::NativeImage *)jarg1;
46147   {
46148     try {
46149       result = (char *)(arg1)->GetCustomFragmentPreFix();
46150     } catch (std::out_of_range& e) {
46151       {
46152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46153       };
46154     } catch (std::exception& e) {
46155       {
46156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46157       };
46158     } catch (Dali::DaliException e) {
46159       {
46160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46161       };
46162     } catch (...) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46165       };
46166     }
46167   }
46168
46169   jresult = SWIG_csharp_string_callback((const char *)result);
46170   return jresult;
46171 }
46172
46173
46174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46175   char * jresult ;
46176   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46177   char *result = 0 ;
46178
46179   arg1 = (Dali::NativeImage *)jarg1;
46180   {
46181     try {
46182       result = (char *)(arg1)->GetCustomSamplerTypename();
46183     } catch (std::out_of_range& e) {
46184       {
46185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (std::exception& e) {
46188       {
46189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46190       };
46191     } catch (Dali::DaliException e) {
46192       {
46193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46194       };
46195     } catch (...) {
46196       {
46197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46198       };
46199     }
46200   }
46201
46202   jresult = SWIG_csharp_string_callback((const char *)result);
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46208   unsigned int jresult ;
46209   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46210   bool result;
46211
46212   arg1 = (Dali::NativeImageInterface *)jarg1;
46213   {
46214     try {
46215       result = (bool)(arg1)->GlExtensionCreate();
46216     } catch (std::out_of_range& e) {
46217       {
46218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (std::exception& e) {
46221       {
46222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46223       };
46224     } catch (Dali::DaliException e) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46227       };
46228     } catch (...) {
46229       {
46230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46231       };
46232     }
46233   }
46234
46235   jresult = result;
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46241   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46242
46243   arg1 = (Dali::NativeImageInterface *)jarg1;
46244   {
46245     try {
46246       (arg1)->GlExtensionDestroy();
46247     } catch (std::out_of_range& e) {
46248       {
46249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46250       };
46251     } catch (std::exception& e) {
46252       {
46253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46254       };
46255     } catch (Dali::DaliException e) {
46256       {
46257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46258       };
46259     } catch (...) {
46260       {
46261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46262       };
46263     }
46264   }
46265
46266 }
46267
46268
46269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46270   unsigned int jresult ;
46271   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46272   unsigned int result;
46273
46274   arg1 = (Dali::NativeImageInterface *)jarg1;
46275   {
46276     try {
46277       result = (unsigned int)(arg1)->TargetTexture();
46278     } catch (std::out_of_range& e) {
46279       {
46280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46281       };
46282     } catch (std::exception& e) {
46283       {
46284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46285       };
46286     } catch (Dali::DaliException e) {
46287       {
46288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46289       };
46290     } catch (...) {
46291       {
46292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46293       };
46294     }
46295   }
46296
46297   jresult = result;
46298   return jresult;
46299 }
46300
46301
46302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46303   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46304
46305   arg1 = (Dali::NativeImageInterface *)jarg1;
46306   {
46307     try {
46308       (arg1)->PrepareTexture();
46309     } catch (std::out_of_range& e) {
46310       {
46311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46312       };
46313     } catch (std::exception& e) {
46314       {
46315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46316       };
46317     } catch (Dali::DaliException e) {
46318       {
46319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46320       };
46321     } catch (...) {
46322       {
46323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46324       };
46325     }
46326   }
46327
46328 }
46329
46330
46331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46332   unsigned int jresult ;
46333   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46334   unsigned int result;
46335
46336   arg1 = (Dali::NativeImageInterface *)jarg1;
46337   {
46338     try {
46339       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46340     } catch (std::out_of_range& e) {
46341       {
46342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46343       };
46344     } catch (std::exception& e) {
46345       {
46346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46347       };
46348     } catch (Dali::DaliException e) {
46349       {
46350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46351       };
46352     } catch (...) {
46353       {
46354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46355       };
46356     }
46357   }
46358
46359   jresult = result;
46360   return jresult;
46361 }
46362
46363
46364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46365   unsigned int jresult ;
46366   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46367   unsigned int result;
46368
46369   arg1 = (Dali::NativeImageInterface *)jarg1;
46370   {
46371     try {
46372       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46373     } catch (std::out_of_range& e) {
46374       {
46375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (std::exception& e) {
46378       {
46379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46380       };
46381     } catch (Dali::DaliException e) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46384       };
46385     } catch (...) {
46386       {
46387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46388       };
46389     }
46390   }
46391
46392   jresult = result;
46393   return jresult;
46394 }
46395
46396
46397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46398   unsigned int jresult ;
46399   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46400   bool result;
46401
46402   arg1 = (Dali::NativeImageInterface *)jarg1;
46403   {
46404     try {
46405       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46406     } catch (std::out_of_range& e) {
46407       {
46408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (std::exception& e) {
46411       {
46412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46413       };
46414     } catch (Dali::DaliException e) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46417       };
46418     } catch (...) {
46419       {
46420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46421       };
46422     }
46423   }
46424
46425   jresult = result;
46426   return jresult;
46427 }
46428
46429
46430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46431   void * jresult ;
46432   std::string *arg1 = 0 ;
46433   Dali::ImageDimensions result;
46434
46435   if (!jarg1) {
46436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46437     return 0;
46438   }
46439   std::string arg1_str(jarg1);
46440   arg1 = &arg1_str;
46441   {
46442     try {
46443       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46444     } catch (std::out_of_range& e) {
46445       {
46446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46447       };
46448     } catch (std::exception& e) {
46449       {
46450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46451       };
46452     } catch (Dali::DaliException e) {
46453       {
46454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46455       };
46456     } catch (...) {
46457       {
46458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46459       };
46460     }
46461   }
46462
46463   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46464
46465   //argout typemap for const std::string&
46466
46467   return jresult;
46468 }
46469
46470
46471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46472   void * jresult ;
46473   Dali::ResourceImage *result = 0 ;
46474
46475   {
46476     try {
46477       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46478     } catch (std::out_of_range& e) {
46479       {
46480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46481       };
46482     } catch (std::exception& e) {
46483       {
46484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46485       };
46486     } catch (Dali::DaliException e) {
46487       {
46488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46489       };
46490     } catch (...) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46493       };
46494     }
46495   }
46496
46497   jresult = (void *)result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46503   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46504
46505   arg1 = (Dali::ResourceImage *)jarg1;
46506   {
46507     try {
46508       delete arg1;
46509     } catch (std::out_of_range& e) {
46510       {
46511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46512       };
46513     } catch (std::exception& e) {
46514       {
46515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46516       };
46517     } catch (Dali::DaliException e) {
46518       {
46519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46520       };
46521     } catch (...) {
46522       {
46523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46524       };
46525     }
46526   }
46527
46528 }
46529
46530
46531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46532   void * jresult ;
46533   Dali::ResourceImage *arg1 = 0 ;
46534   Dali::ResourceImage *result = 0 ;
46535
46536   arg1 = (Dali::ResourceImage *)jarg1;
46537   if (!arg1) {
46538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46539     return 0;
46540   }
46541   {
46542     try {
46543       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46544     } catch (std::out_of_range& e) {
46545       {
46546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (std::exception& e) {
46549       {
46550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (Dali::DaliException e) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46555       };
46556     } catch (...) {
46557       {
46558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46559       };
46560     }
46561   }
46562
46563   jresult = (void *)result;
46564   return jresult;
46565 }
46566
46567
46568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46569   void * jresult ;
46570   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46571   Dali::ResourceImage *arg2 = 0 ;
46572   Dali::ResourceImage *result = 0 ;
46573
46574   arg1 = (Dali::ResourceImage *)jarg1;
46575   arg2 = (Dali::ResourceImage *)jarg2;
46576   if (!arg2) {
46577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46578     return 0;
46579   }
46580   {
46581     try {
46582       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46583     } catch (std::out_of_range& e) {
46584       {
46585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46586       };
46587     } catch (std::exception& e) {
46588       {
46589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46590       };
46591     } catch (Dali::DaliException e) {
46592       {
46593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46594       };
46595     } catch (...) {
46596       {
46597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46598       };
46599     }
46600   }
46601
46602   jresult = (void *)result;
46603   return jresult;
46604 }
46605
46606
46607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46608   void * jresult ;
46609   std::string *arg1 = 0 ;
46610   bool arg2 ;
46611   Dali::ResourceImage result;
46612
46613   if (!jarg1) {
46614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46615     return 0;
46616   }
46617   std::string arg1_str(jarg1);
46618   arg1 = &arg1_str;
46619   arg2 = jarg2 ? true : false;
46620   {
46621     try {
46622       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46623     } catch (std::out_of_range& e) {
46624       {
46625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46626       };
46627     } catch (std::exception& e) {
46628       {
46629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (Dali::DaliException e) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641
46642   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46643
46644   //argout typemap for const std::string&
46645
46646   return jresult;
46647 }
46648
46649
46650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46651   void * jresult ;
46652   std::string *arg1 = 0 ;
46653   Dali::ResourceImage result;
46654
46655   if (!jarg1) {
46656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46657     return 0;
46658   }
46659   std::string arg1_str(jarg1);
46660   arg1 = &arg1_str;
46661   {
46662     try {
46663       result = Dali::ResourceImage::New((std::string const &)*arg1);
46664     } catch (std::out_of_range& e) {
46665       {
46666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (std::exception& e) {
46669       {
46670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46671       };
46672     } catch (Dali::DaliException e) {
46673       {
46674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46675       };
46676     } catch (...) {
46677       {
46678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46679       };
46680     }
46681   }
46682
46683   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46684
46685   //argout typemap for const std::string&
46686
46687   return jresult;
46688 }
46689
46690
46691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46692   void * jresult ;
46693   std::string *arg1 = 0 ;
46694   Dali::ImageDimensions arg2 ;
46695   Dali::FittingMode::Type arg3 ;
46696   Dali::SamplingMode::Type arg4 ;
46697   bool arg5 ;
46698   Dali::ImageDimensions *argp2 ;
46699   Dali::ResourceImage result;
46700
46701   if (!jarg1) {
46702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46703     return 0;
46704   }
46705   std::string arg1_str(jarg1);
46706   arg1 = &arg1_str;
46707   argp2 = (Dali::ImageDimensions *)jarg2;
46708   if (!argp2) {
46709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46710     return 0;
46711   }
46712   arg2 = *argp2;
46713   arg3 = (Dali::FittingMode::Type)jarg3;
46714   arg4 = (Dali::SamplingMode::Type)jarg4;
46715   arg5 = jarg5 ? true : false;
46716   {
46717     try {
46718       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46719     } catch (std::out_of_range& e) {
46720       {
46721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46722       };
46723     } catch (std::exception& e) {
46724       {
46725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46726       };
46727     } catch (Dali::DaliException e) {
46728       {
46729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46730       };
46731     } catch (...) {
46732       {
46733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46734       };
46735     }
46736   }
46737
46738   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46739
46740   //argout typemap for const std::string&
46741
46742   return jresult;
46743 }
46744
46745
46746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46747   void * jresult ;
46748   std::string *arg1 = 0 ;
46749   Dali::ImageDimensions arg2 ;
46750   Dali::FittingMode::Type arg3 ;
46751   Dali::SamplingMode::Type arg4 ;
46752   Dali::ImageDimensions *argp2 ;
46753   Dali::ResourceImage result;
46754
46755   if (!jarg1) {
46756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46757     return 0;
46758   }
46759   std::string arg1_str(jarg1);
46760   arg1 = &arg1_str;
46761   argp2 = (Dali::ImageDimensions *)jarg2;
46762   if (!argp2) {
46763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46764     return 0;
46765   }
46766   arg2 = *argp2;
46767   arg3 = (Dali::FittingMode::Type)jarg3;
46768   arg4 = (Dali::SamplingMode::Type)jarg4;
46769   {
46770     try {
46771       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46772     } catch (std::out_of_range& e) {
46773       {
46774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46775       };
46776     } catch (std::exception& e) {
46777       {
46778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46779       };
46780     } catch (Dali::DaliException e) {
46781       {
46782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46783       };
46784     } catch (...) {
46785       {
46786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46787       };
46788     }
46789   }
46790
46791   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46792
46793   //argout typemap for const std::string&
46794
46795   return jresult;
46796 }
46797
46798
46799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46800   void * jresult ;
46801   std::string *arg1 = 0 ;
46802   Dali::ImageDimensions arg2 ;
46803   Dali::FittingMode::Type arg3 ;
46804   Dali::ImageDimensions *argp2 ;
46805   Dali::ResourceImage result;
46806
46807   if (!jarg1) {
46808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46809     return 0;
46810   }
46811   std::string arg1_str(jarg1);
46812   arg1 = &arg1_str;
46813   argp2 = (Dali::ImageDimensions *)jarg2;
46814   if (!argp2) {
46815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46816     return 0;
46817   }
46818   arg2 = *argp2;
46819   arg3 = (Dali::FittingMode::Type)jarg3;
46820   {
46821     try {
46822       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46823     } catch (std::out_of_range& e) {
46824       {
46825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46826       };
46827     } catch (std::exception& e) {
46828       {
46829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46830       };
46831     } catch (Dali::DaliException e) {
46832       {
46833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46834       };
46835     } catch (...) {
46836       {
46837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46838       };
46839     }
46840   }
46841
46842   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46843
46844   //argout typemap for const std::string&
46845
46846   return jresult;
46847 }
46848
46849
46850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46851   void * jresult ;
46852   std::string *arg1 = 0 ;
46853   Dali::ImageDimensions arg2 ;
46854   Dali::ImageDimensions *argp2 ;
46855   Dali::ResourceImage result;
46856
46857   if (!jarg1) {
46858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46859     return 0;
46860   }
46861   std::string arg1_str(jarg1);
46862   arg1 = &arg1_str;
46863   argp2 = (Dali::ImageDimensions *)jarg2;
46864   if (!argp2) {
46865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46866     return 0;
46867   }
46868   arg2 = *argp2;
46869   {
46870     try {
46871       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46872     } catch (std::out_of_range& e) {
46873       {
46874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46875       };
46876     } catch (std::exception& e) {
46877       {
46878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46879       };
46880     } catch (Dali::DaliException e) {
46881       {
46882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46883       };
46884     } catch (...) {
46885       {
46886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46887       };
46888     }
46889   }
46890
46891   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46892
46893   //argout typemap for const std::string&
46894
46895   return jresult;
46896 }
46897
46898
46899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46900   void * jresult ;
46901   Dali::BaseHandle arg1 ;
46902   Dali::BaseHandle *argp1 ;
46903   Dali::ResourceImage result;
46904
46905   argp1 = (Dali::BaseHandle *)jarg1;
46906   if (!argp1) {
46907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46908     return 0;
46909   }
46910   arg1 = *argp1;
46911   {
46912     try {
46913       result = Dali::ResourceImage::DownCast(arg1);
46914     } catch (std::out_of_range& e) {
46915       {
46916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46917       };
46918     } catch (std::exception& e) {
46919       {
46920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46921       };
46922     } catch (Dali::DaliException e) {
46923       {
46924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46925       };
46926     } catch (...) {
46927       {
46928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46929       };
46930     }
46931   }
46932
46933   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46934   return jresult;
46935 }
46936
46937
46938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46939   int jresult ;
46940   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46941   Dali::LoadingState result;
46942
46943   arg1 = (Dali::ResourceImage *)jarg1;
46944   {
46945     try {
46946       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46947     } catch (std::out_of_range& e) {
46948       {
46949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46950       };
46951     } catch (std::exception& e) {
46952       {
46953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46954       };
46955     } catch (Dali::DaliException e) {
46956       {
46957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46958       };
46959     } catch (...) {
46960       {
46961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46962       };
46963     }
46964   }
46965
46966   jresult = (int)result;
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46972   char * jresult ;
46973   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46974   std::string result;
46975
46976   arg1 = (Dali::ResourceImage *)jarg1;
46977   {
46978     try {
46979       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46980     } catch (std::out_of_range& e) {
46981       {
46982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (std::exception& e) {
46985       {
46986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46987       };
46988     } catch (Dali::DaliException e) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46991       };
46992     } catch (...) {
46993       {
46994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46995       };
46996     }
46997   }
46998
46999   jresult = SWIG_csharp_string_callback((&result)->c_str());
47000   return jresult;
47001 }
47002
47003
47004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47005   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47006
47007   arg1 = (Dali::ResourceImage *)jarg1;
47008   {
47009     try {
47010       (arg1)->Reload();
47011     } catch (std::out_of_range& e) {
47012       {
47013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47014       };
47015     } catch (std::exception& e) {
47016       {
47017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47018       };
47019     } catch (Dali::DaliException e) {
47020       {
47021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47022       };
47023     } catch (...) {
47024       {
47025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47026       };
47027     }
47028   }
47029
47030 }
47031
47032
47033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47034   void * jresult ;
47035   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47036   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47037
47038   arg1 = (Dali::ResourceImage *)jarg1;
47039   {
47040     try {
47041       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47042     } catch (std::out_of_range& e) {
47043       {
47044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47045       };
47046     } catch (std::exception& e) {
47047       {
47048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47049       };
47050     } catch (Dali::DaliException e) {
47051       {
47052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47053       };
47054     } catch (...) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47057       };
47058     }
47059   }
47060
47061   jresult = (void *)result;
47062   return jresult;
47063 }
47064
47065
47066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47067   void * jresult ;
47068   Dali::FrameBufferImage *result = 0 ;
47069
47070   {
47071     try {
47072       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47073     } catch (std::out_of_range& e) {
47074       {
47075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47076       };
47077     } catch (std::exception& e) {
47078       {
47079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47080       };
47081     } catch (Dali::DaliException e) {
47082       {
47083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47084       };
47085     } catch (...) {
47086       {
47087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47088       };
47089     }
47090   }
47091
47092   jresult = (void *)result;
47093   return jresult;
47094 }
47095
47096
47097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47098   void * jresult ;
47099   unsigned int arg1 ;
47100   unsigned int arg2 ;
47101   Dali::Pixel::Format arg3 ;
47102   Dali::RenderBuffer::Format arg4 ;
47103   Dali::FrameBufferImage result;
47104
47105   arg1 = (unsigned int)jarg1;
47106   arg2 = (unsigned int)jarg2;
47107   arg3 = (Dali::Pixel::Format)jarg3;
47108   arg4 = (Dali::RenderBuffer::Format)jarg4;
47109   {
47110     try {
47111       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47112     } catch (std::out_of_range& e) {
47113       {
47114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47115       };
47116     } catch (std::exception& e) {
47117       {
47118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47119       };
47120     } catch (Dali::DaliException e) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47123       };
47124     } catch (...) {
47125       {
47126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47127       };
47128     }
47129   }
47130
47131   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47132   return jresult;
47133 }
47134
47135
47136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47137   void * jresult ;
47138   unsigned int arg1 ;
47139   unsigned int arg2 ;
47140   Dali::Pixel::Format arg3 ;
47141   Dali::FrameBufferImage result;
47142
47143   arg1 = (unsigned int)jarg1;
47144   arg2 = (unsigned int)jarg2;
47145   arg3 = (Dali::Pixel::Format)jarg3;
47146   {
47147     try {
47148       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47149     } catch (std::out_of_range& e) {
47150       {
47151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (std::exception& e) {
47154       {
47155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47156       };
47157     } catch (Dali::DaliException e) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47160       };
47161     } catch (...) {
47162       {
47163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47164       };
47165     }
47166   }
47167
47168   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47169   return jresult;
47170 }
47171
47172
47173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47174   void * jresult ;
47175   unsigned int arg1 ;
47176   unsigned int arg2 ;
47177   Dali::FrameBufferImage result;
47178
47179   arg1 = (unsigned int)jarg1;
47180   arg2 = (unsigned int)jarg2;
47181   {
47182     try {
47183       result = Dali::FrameBufferImage::New(arg1,arg2);
47184     } catch (std::out_of_range& e) {
47185       {
47186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (std::exception& e) {
47189       {
47190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (Dali::DaliException e) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47195       };
47196     } catch (...) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47199       };
47200     }
47201   }
47202
47203   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47204   return jresult;
47205 }
47206
47207
47208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47209   void * jresult ;
47210   unsigned int arg1 ;
47211   Dali::FrameBufferImage result;
47212
47213   arg1 = (unsigned int)jarg1;
47214   {
47215     try {
47216       result = Dali::FrameBufferImage::New(arg1);
47217     } catch (std::out_of_range& e) {
47218       {
47219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (std::exception& e) {
47222       {
47223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47224       };
47225     } catch (Dali::DaliException e) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47228       };
47229     } catch (...) {
47230       {
47231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47232       };
47233     }
47234   }
47235
47236   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47237   return jresult;
47238 }
47239
47240
47241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47242   void * jresult ;
47243   Dali::FrameBufferImage result;
47244
47245   {
47246     try {
47247       result = Dali::FrameBufferImage::New();
47248     } catch (std::out_of_range& e) {
47249       {
47250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (std::exception& e) {
47253       {
47254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47255       };
47256     } catch (Dali::DaliException e) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47259       };
47260     } catch (...) {
47261       {
47262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47263       };
47264     }
47265   }
47266
47267   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47268   return jresult;
47269 }
47270
47271
47272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47273   void * jresult ;
47274   Dali::NativeImageInterface *arg1 = 0 ;
47275   Dali::FrameBufferImage result;
47276
47277   arg1 = (Dali::NativeImageInterface *)jarg1;
47278   if (!arg1) {
47279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47280     return 0;
47281   }
47282   {
47283     try {
47284       result = Dali::FrameBufferImage::New(*arg1);
47285     } catch (std::out_of_range& e) {
47286       {
47287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (std::exception& e) {
47290       {
47291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47292       };
47293     } catch (Dali::DaliException e) {
47294       {
47295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47296       };
47297     } catch (...) {
47298       {
47299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47300       };
47301     }
47302   }
47303
47304   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47310   void * jresult ;
47311   Dali::BaseHandle arg1 ;
47312   Dali::BaseHandle *argp1 ;
47313   Dali::FrameBufferImage result;
47314
47315   argp1 = (Dali::BaseHandle *)jarg1;
47316   if (!argp1) {
47317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47318     return 0;
47319   }
47320   arg1 = *argp1;
47321   {
47322     try {
47323       result = Dali::FrameBufferImage::DownCast(arg1);
47324     } catch (std::out_of_range& e) {
47325       {
47326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (std::exception& e) {
47329       {
47330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47331       };
47332     } catch (Dali::DaliException e) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47339       };
47340     }
47341   }
47342
47343   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47349   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47350
47351   arg1 = (Dali::FrameBufferImage *)jarg1;
47352   {
47353     try {
47354       delete arg1;
47355     } catch (std::out_of_range& e) {
47356       {
47357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47358       };
47359     } catch (std::exception& e) {
47360       {
47361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47362       };
47363     } catch (Dali::DaliException e) {
47364       {
47365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47366       };
47367     } catch (...) {
47368       {
47369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47370       };
47371     }
47372   }
47373
47374 }
47375
47376
47377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47378   void * jresult ;
47379   Dali::FrameBufferImage *arg1 = 0 ;
47380   Dali::FrameBufferImage *result = 0 ;
47381
47382   arg1 = (Dali::FrameBufferImage *)jarg1;
47383   if (!arg1) {
47384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47385     return 0;
47386   }
47387   {
47388     try {
47389       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47390     } catch (std::out_of_range& e) {
47391       {
47392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47393       };
47394     } catch (std::exception& e) {
47395       {
47396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (Dali::DaliException e) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47401       };
47402     } catch (...) {
47403       {
47404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47405       };
47406     }
47407   }
47408
47409   jresult = (void *)result;
47410   return jresult;
47411 }
47412
47413
47414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47415   void * jresult ;
47416   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47417   Dali::FrameBufferImage *arg2 = 0 ;
47418   Dali::FrameBufferImage *result = 0 ;
47419
47420   arg1 = (Dali::FrameBufferImage *)jarg1;
47421   arg2 = (Dali::FrameBufferImage *)jarg2;
47422   if (!arg2) {
47423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47424     return 0;
47425   }
47426   {
47427     try {
47428       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47429     } catch (std::out_of_range& e) {
47430       {
47431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47432       };
47433     } catch (std::exception& e) {
47434       {
47435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47436       };
47437     } catch (Dali::DaliException e) {
47438       {
47439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47440       };
47441     } catch (...) {
47442       {
47443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47444       };
47445     }
47446   }
47447
47448   jresult = (void *)result;
47449   return jresult;
47450 }
47451
47452
47453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47454   void * jresult ;
47455   Dali::NinePatchImage *result = 0 ;
47456
47457   {
47458     try {
47459       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47460     } catch (std::out_of_range& e) {
47461       {
47462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47463       };
47464     } catch (std::exception& e) {
47465       {
47466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47467       };
47468     } catch (Dali::DaliException e) {
47469       {
47470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47471       };
47472     } catch (...) {
47473       {
47474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47475       };
47476     }
47477   }
47478
47479   jresult = (void *)result;
47480   return jresult;
47481 }
47482
47483
47484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47485   void * jresult ;
47486   std::string *arg1 = 0 ;
47487   Dali::NinePatchImage result;
47488
47489   if (!jarg1) {
47490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47491     return 0;
47492   }
47493   std::string arg1_str(jarg1);
47494   arg1 = &arg1_str;
47495   {
47496     try {
47497       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47498     } catch (std::out_of_range& e) {
47499       {
47500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47501       };
47502     } catch (std::exception& e) {
47503       {
47504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47505       };
47506     } catch (Dali::DaliException e) {
47507       {
47508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47509       };
47510     } catch (...) {
47511       {
47512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47513       };
47514     }
47515   }
47516
47517   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47518
47519   //argout typemap for const std::string&
47520
47521   return jresult;
47522 }
47523
47524
47525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47526   void * jresult ;
47527   Dali::BaseHandle arg1 ;
47528   Dali::BaseHandle *argp1 ;
47529   Dali::NinePatchImage result;
47530
47531   argp1 = (Dali::BaseHandle *)jarg1;
47532   if (!argp1) {
47533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47534     return 0;
47535   }
47536   arg1 = *argp1;
47537   {
47538     try {
47539       result = Dali::NinePatchImage::DownCast(arg1);
47540     } catch (std::out_of_range& e) {
47541       {
47542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47543       };
47544     } catch (std::exception& e) {
47545       {
47546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47547       };
47548     } catch (Dali::DaliException e) {
47549       {
47550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47551       };
47552     } catch (...) {
47553       {
47554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47555       };
47556     }
47557   }
47558
47559   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47560   return jresult;
47561 }
47562
47563
47564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47565   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47566
47567   arg1 = (Dali::NinePatchImage *)jarg1;
47568   {
47569     try {
47570       delete arg1;
47571     } catch (std::out_of_range& e) {
47572       {
47573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47574       };
47575     } catch (std::exception& e) {
47576       {
47577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47578       };
47579     } catch (Dali::DaliException e) {
47580       {
47581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47582       };
47583     } catch (...) {
47584       {
47585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47586       };
47587     }
47588   }
47589
47590 }
47591
47592
47593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47594   void * jresult ;
47595   Dali::NinePatchImage *arg1 = 0 ;
47596   Dali::NinePatchImage *result = 0 ;
47597
47598   arg1 = (Dali::NinePatchImage *)jarg1;
47599   if (!arg1) {
47600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47601     return 0;
47602   }
47603   {
47604     try {
47605       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47606     } catch (std::out_of_range& e) {
47607       {
47608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47609       };
47610     } catch (std::exception& e) {
47611       {
47612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47613       };
47614     } catch (Dali::DaliException e) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47617       };
47618     } catch (...) {
47619       {
47620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47621       };
47622     }
47623   }
47624
47625   jresult = (void *)result;
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47631   void * jresult ;
47632   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47633   Dali::NinePatchImage *arg2 = 0 ;
47634   Dali::NinePatchImage *result = 0 ;
47635
47636   arg1 = (Dali::NinePatchImage *)jarg1;
47637   arg2 = (Dali::NinePatchImage *)jarg2;
47638   if (!arg2) {
47639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47640     return 0;
47641   }
47642   {
47643     try {
47644       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47645     } catch (std::out_of_range& e) {
47646       {
47647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47648       };
47649     } catch (std::exception& e) {
47650       {
47651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47652       };
47653     } catch (Dali::DaliException e) {
47654       {
47655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47656       };
47657     } catch (...) {
47658       {
47659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47660       };
47661     }
47662   }
47663
47664   jresult = (void *)result;
47665   return jresult;
47666 }
47667
47668
47669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47670   void * jresult ;
47671   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47672   Dali::Vector4 result;
47673
47674   arg1 = (Dali::NinePatchImage *)jarg1;
47675   {
47676     try {
47677       result = (arg1)->GetStretchBorders();
47678     } catch (std::out_of_range& e) {
47679       {
47680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47681       };
47682     } catch (std::exception& e) {
47683       {
47684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47685       };
47686     } catch (Dali::DaliException e) {
47687       {
47688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47689       };
47690     } catch (...) {
47691       {
47692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47693       };
47694     }
47695   }
47696
47697   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47698   return jresult;
47699 }
47700
47701
47702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47703   void * jresult ;
47704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47705   Dali::NinePatchImage::StretchRanges *result = 0 ;
47706
47707   arg1 = (Dali::NinePatchImage *)jarg1;
47708   {
47709     try {
47710       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47711     } catch (std::out_of_range& e) {
47712       {
47713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (std::exception& e) {
47716       {
47717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47718       };
47719     } catch (Dali::DaliException e) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47722       };
47723     } catch (...) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47726       };
47727     }
47728   }
47729
47730   jresult = (void *)result;
47731   return jresult;
47732 }
47733
47734
47735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47736   void * jresult ;
47737   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47738   Dali::NinePatchImage::StretchRanges *result = 0 ;
47739
47740   arg1 = (Dali::NinePatchImage *)jarg1;
47741   {
47742     try {
47743       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47744     } catch (std::out_of_range& e) {
47745       {
47746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (std::exception& e) {
47749       {
47750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47751       };
47752     } catch (Dali::DaliException e) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47759       };
47760     }
47761   }
47762
47763   jresult = (void *)result;
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47769   void * jresult ;
47770   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47771   Dali::Rect< int > result;
47772
47773   arg1 = (Dali::NinePatchImage *)jarg1;
47774   {
47775     try {
47776       result = (arg1)->GetChildRectangle();
47777     } catch (std::out_of_range& e) {
47778       {
47779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (std::exception& e) {
47782       {
47783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47784       };
47785     } catch (Dali::DaliException e) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47788       };
47789     } catch (...) {
47790       {
47791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47792       };
47793     }
47794   }
47795
47796   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47797   return jresult;
47798 }
47799
47800
47801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47802   void * jresult ;
47803   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47804   Dali::BufferImage result;
47805
47806   arg1 = (Dali::NinePatchImage *)jarg1;
47807   {
47808     try {
47809       result = (arg1)->CreateCroppedBufferImage();
47810     } catch (std::out_of_range& e) {
47811       {
47812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (std::exception& e) {
47815       {
47816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47817       };
47818     } catch (Dali::DaliException e) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47821       };
47822     } catch (...) {
47823       {
47824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47825       };
47826     }
47827   }
47828
47829   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47835   unsigned int jresult ;
47836   std::string *arg1 = 0 ;
47837   bool result;
47838
47839   if (!jarg1) {
47840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47841     return 0;
47842   }
47843   std::string arg1_str(jarg1);
47844   arg1 = &arg1_str;
47845   {
47846     try {
47847       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47848     } catch (std::out_of_range& e) {
47849       {
47850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47851       };
47852     } catch (std::exception& e) {
47853       {
47854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47855       };
47856     } catch (Dali::DaliException e) {
47857       {
47858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47859       };
47860     } catch (...) {
47861       {
47862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47863       };
47864     }
47865   }
47866
47867   jresult = result;
47868
47869   //argout typemap for const std::string&
47870
47871   return jresult;
47872 }
47873
47874
47875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47876   int jresult ;
47877   int result;
47878
47879   result = (int)Dali::CameraActor::Property::TYPE;
47880   jresult = (int)result;
47881   return jresult;
47882 }
47883
47884
47885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47886   int jresult ;
47887   int result;
47888
47889   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47890   jresult = (int)result;
47891   return jresult;
47892 }
47893
47894
47895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47896   int jresult ;
47897   int result;
47898
47899   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47900   jresult = (int)result;
47901   return jresult;
47902 }
47903
47904
47905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47906   int jresult ;
47907   int result;
47908
47909   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47910   jresult = (int)result;
47911   return jresult;
47912 }
47913
47914
47915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47916   int jresult ;
47917   int result;
47918
47919   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47920   jresult = (int)result;
47921   return jresult;
47922 }
47923
47924
47925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47926   int jresult ;
47927   int result;
47928
47929   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47930   jresult = (int)result;
47931   return jresult;
47932 }
47933
47934
47935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47936   int jresult ;
47937   int result;
47938
47939   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47940   jresult = (int)result;
47941   return jresult;
47942 }
47943
47944
47945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47946   int jresult ;
47947   int result;
47948
47949   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47950   jresult = (int)result;
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47956   int jresult ;
47957   int result;
47958
47959   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47960   jresult = (int)result;
47961   return jresult;
47962 }
47963
47964
47965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47966   int jresult ;
47967   int result;
47968
47969   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47970   jresult = (int)result;
47971   return jresult;
47972 }
47973
47974
47975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47976   int jresult ;
47977   int result;
47978
47979   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
47980   jresult = (int)result;
47981   return jresult;
47982 }
47983
47984
47985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
47986   int jresult ;
47987   int result;
47988
47989   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
47990   jresult = (int)result;
47991   return jresult;
47992 }
47993
47994
47995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
47996   int jresult ;
47997   int result;
47998
47999   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48000   jresult = (int)result;
48001   return jresult;
48002 }
48003
48004
48005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48006   int jresult ;
48007   int result;
48008
48009   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48010   jresult = (int)result;
48011   return jresult;
48012 }
48013
48014
48015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48016   void * jresult ;
48017   Dali::CameraActor::Property *result = 0 ;
48018
48019   {
48020     try {
48021       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48022     } catch (std::out_of_range& e) {
48023       {
48024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48025       };
48026     } catch (std::exception& e) {
48027       {
48028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48029       };
48030     } catch (Dali::DaliException e) {
48031       {
48032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48033       };
48034     } catch (...) {
48035       {
48036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48037       };
48038     }
48039   }
48040
48041   jresult = (void *)result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48047   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48048
48049   arg1 = (Dali::CameraActor::Property *)jarg1;
48050   {
48051     try {
48052       delete arg1;
48053     } catch (std::out_of_range& e) {
48054       {
48055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48056       };
48057     } catch (std::exception& e) {
48058       {
48059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48060       };
48061     } catch (Dali::DaliException e) {
48062       {
48063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48064       };
48065     } catch (...) {
48066       {
48067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48068       };
48069     }
48070   }
48071
48072 }
48073
48074
48075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48076   void * jresult ;
48077   Dali::CameraActor *result = 0 ;
48078
48079   {
48080     try {
48081       result = (Dali::CameraActor *)new Dali::CameraActor();
48082     } catch (std::out_of_range& e) {
48083       {
48084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48085       };
48086     } catch (std::exception& e) {
48087       {
48088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48089       };
48090     } catch (Dali::DaliException e) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48097       };
48098     }
48099   }
48100
48101   jresult = (void *)result;
48102   return jresult;
48103 }
48104
48105
48106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48107   void * jresult ;
48108   Dali::CameraActor result;
48109
48110   {
48111     try {
48112       result = Dali::CameraActor::New();
48113     } catch (std::out_of_range& e) {
48114       {
48115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48116       };
48117     } catch (std::exception& e) {
48118       {
48119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48120       };
48121     } catch (Dali::DaliException e) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48124       };
48125     } catch (...) {
48126       {
48127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48128       };
48129     }
48130   }
48131
48132   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48133   return jresult;
48134 }
48135
48136
48137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48138   void * jresult ;
48139   Dali::Size *arg1 = 0 ;
48140   Dali::CameraActor result;
48141
48142   arg1 = (Dali::Size *)jarg1;
48143   if (!arg1) {
48144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48145     return 0;
48146   }
48147   {
48148     try {
48149       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48150     } catch (std::out_of_range& e) {
48151       {
48152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48153       };
48154     } catch (std::exception& e) {
48155       {
48156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48157       };
48158     } catch (Dali::DaliException e) {
48159       {
48160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48161       };
48162     } catch (...) {
48163       {
48164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48165       };
48166     }
48167   }
48168
48169   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48170   return jresult;
48171 }
48172
48173
48174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48175   void * jresult ;
48176   Dali::BaseHandle arg1 ;
48177   Dali::BaseHandle *argp1 ;
48178   Dali::CameraActor result;
48179
48180   argp1 = (Dali::BaseHandle *)jarg1;
48181   if (!argp1) {
48182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48183     return 0;
48184   }
48185   arg1 = *argp1;
48186   {
48187     try {
48188       result = Dali::CameraActor::DownCast(arg1);
48189     } catch (std::out_of_range& e) {
48190       {
48191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48192       };
48193     } catch (std::exception& e) {
48194       {
48195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48196       };
48197     } catch (Dali::DaliException e) {
48198       {
48199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48200       };
48201     } catch (...) {
48202       {
48203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48204       };
48205     }
48206   }
48207
48208   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48209   return jresult;
48210 }
48211
48212
48213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48214   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48215
48216   arg1 = (Dali::CameraActor *)jarg1;
48217   {
48218     try {
48219       delete arg1;
48220     } catch (std::out_of_range& e) {
48221       {
48222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48223       };
48224     } catch (std::exception& e) {
48225       {
48226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48227       };
48228     } catch (Dali::DaliException e) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48231       };
48232     } catch (...) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48235       };
48236     }
48237   }
48238
48239 }
48240
48241
48242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48243   void * jresult ;
48244   Dali::CameraActor *arg1 = 0 ;
48245   Dali::CameraActor *result = 0 ;
48246
48247   arg1 = (Dali::CameraActor *)jarg1;
48248   if (!arg1) {
48249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48250     return 0;
48251   }
48252   {
48253     try {
48254       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48255     } catch (std::out_of_range& e) {
48256       {
48257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48258       };
48259     } catch (std::exception& e) {
48260       {
48261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48262       };
48263     } catch (Dali::DaliException e) {
48264       {
48265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48266       };
48267     } catch (...) {
48268       {
48269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48270       };
48271     }
48272   }
48273
48274   jresult = (void *)result;
48275   return jresult;
48276 }
48277
48278
48279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48280   void * jresult ;
48281   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48282   Dali::CameraActor *arg2 = 0 ;
48283   Dali::CameraActor *result = 0 ;
48284
48285   arg1 = (Dali::CameraActor *)jarg1;
48286   arg2 = (Dali::CameraActor *)jarg2;
48287   if (!arg2) {
48288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48289     return 0;
48290   }
48291   {
48292     try {
48293       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48294     } catch (std::out_of_range& e) {
48295       {
48296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48297       };
48298     } catch (std::exception& e) {
48299       {
48300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48301       };
48302     } catch (Dali::DaliException e) {
48303       {
48304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48305       };
48306     } catch (...) {
48307       {
48308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48309       };
48310     }
48311   }
48312
48313   jresult = (void *)result;
48314   return jresult;
48315 }
48316
48317
48318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48319   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48320   Dali::Camera::Type arg2 ;
48321
48322   arg1 = (Dali::CameraActor *)jarg1;
48323   arg2 = (Dali::Camera::Type)jarg2;
48324   {
48325     try {
48326       (arg1)->SetType(arg2);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48334       };
48335     } catch (Dali::DaliException e) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48338       };
48339     } catch (...) {
48340       {
48341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48342       };
48343     }
48344   }
48345
48346 }
48347
48348
48349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48350   int jresult ;
48351   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48352   Dali::Camera::Type result;
48353
48354   arg1 = (Dali::CameraActor *)jarg1;
48355   {
48356     try {
48357       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48358     } catch (std::out_of_range& e) {
48359       {
48360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48361       };
48362     } catch (std::exception& e) {
48363       {
48364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48365       };
48366     } catch (Dali::DaliException e) {
48367       {
48368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48369       };
48370     } catch (...) {
48371       {
48372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48373       };
48374     }
48375   }
48376
48377   jresult = (int)result;
48378   return jresult;
48379 }
48380
48381
48382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48384   Dali::Camera::ProjectionMode arg2 ;
48385
48386   arg1 = (Dali::CameraActor *)jarg1;
48387   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48388   {
48389     try {
48390       (arg1)->SetProjectionMode(arg2);
48391     } catch (std::out_of_range& e) {
48392       {
48393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48394       };
48395     } catch (std::exception& e) {
48396       {
48397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48398       };
48399     } catch (Dali::DaliException e) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48402       };
48403     } catch (...) {
48404       {
48405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48406       };
48407     }
48408   }
48409
48410 }
48411
48412
48413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48414   int jresult ;
48415   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48416   Dali::Camera::ProjectionMode result;
48417
48418   arg1 = (Dali::CameraActor *)jarg1;
48419   {
48420     try {
48421       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48422     } catch (std::out_of_range& e) {
48423       {
48424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48425       };
48426     } catch (std::exception& e) {
48427       {
48428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48429       };
48430     } catch (Dali::DaliException e) {
48431       {
48432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48433       };
48434     } catch (...) {
48435       {
48436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48437       };
48438     }
48439   }
48440
48441   jresult = (int)result;
48442   return jresult;
48443 }
48444
48445
48446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48447   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48448   float arg2 ;
48449
48450   arg1 = (Dali::CameraActor *)jarg1;
48451   arg2 = (float)jarg2;
48452   {
48453     try {
48454       (arg1)->SetFieldOfView(arg2);
48455     } catch (std::out_of_range& e) {
48456       {
48457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48458       };
48459     } catch (std::exception& e) {
48460       {
48461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48462       };
48463     } catch (Dali::DaliException e) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48466       };
48467     } catch (...) {
48468       {
48469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48470       };
48471     }
48472   }
48473
48474 }
48475
48476
48477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48478   float jresult ;
48479   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48480   float result;
48481
48482   arg1 = (Dali::CameraActor *)jarg1;
48483   {
48484     try {
48485       result = (float)(arg1)->GetFieldOfView();
48486     } catch (std::out_of_range& e) {
48487       {
48488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48489       };
48490     } catch (std::exception& e) {
48491       {
48492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48493       };
48494     } catch (Dali::DaliException e) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48497       };
48498     } catch (...) {
48499       {
48500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48501       };
48502     }
48503   }
48504
48505   jresult = result;
48506   return jresult;
48507 }
48508
48509
48510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48511   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48512   float arg2 ;
48513
48514   arg1 = (Dali::CameraActor *)jarg1;
48515   arg2 = (float)jarg2;
48516   {
48517     try {
48518       (arg1)->SetAspectRatio(arg2);
48519     } catch (std::out_of_range& e) {
48520       {
48521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48522       };
48523     } catch (std::exception& e) {
48524       {
48525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48526       };
48527     } catch (Dali::DaliException e) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48530       };
48531     } catch (...) {
48532       {
48533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48534       };
48535     }
48536   }
48537
48538 }
48539
48540
48541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48542   float jresult ;
48543   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48544   float result;
48545
48546   arg1 = (Dali::CameraActor *)jarg1;
48547   {
48548     try {
48549       result = (float)(arg1)->GetAspectRatio();
48550     } catch (std::out_of_range& e) {
48551       {
48552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48553       };
48554     } catch (std::exception& e) {
48555       {
48556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48557       };
48558     } catch (Dali::DaliException e) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48561       };
48562     } catch (...) {
48563       {
48564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48565       };
48566     }
48567   }
48568
48569   jresult = result;
48570   return jresult;
48571 }
48572
48573
48574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48575   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48576   float arg2 ;
48577
48578   arg1 = (Dali::CameraActor *)jarg1;
48579   arg2 = (float)jarg2;
48580   {
48581     try {
48582       (arg1)->SetNearClippingPlane(arg2);
48583     } catch (std::out_of_range& e) {
48584       {
48585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48586       };
48587     } catch (std::exception& e) {
48588       {
48589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48590       };
48591     } catch (Dali::DaliException e) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48594       };
48595     } catch (...) {
48596       {
48597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48598       };
48599     }
48600   }
48601
48602 }
48603
48604
48605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48606   float jresult ;
48607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48608   float result;
48609
48610   arg1 = (Dali::CameraActor *)jarg1;
48611   {
48612     try {
48613       result = (float)(arg1)->GetNearClippingPlane();
48614     } catch (std::out_of_range& e) {
48615       {
48616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48617       };
48618     } catch (std::exception& e) {
48619       {
48620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48621       };
48622     } catch (Dali::DaliException e) {
48623       {
48624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48625       };
48626     } catch (...) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48629       };
48630     }
48631   }
48632
48633   jresult = result;
48634   return jresult;
48635 }
48636
48637
48638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48639   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48640   float arg2 ;
48641
48642   arg1 = (Dali::CameraActor *)jarg1;
48643   arg2 = (float)jarg2;
48644   {
48645     try {
48646       (arg1)->SetFarClippingPlane(arg2);
48647     } catch (std::out_of_range& e) {
48648       {
48649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48650       };
48651     } catch (std::exception& e) {
48652       {
48653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48654       };
48655     } catch (Dali::DaliException e) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48658       };
48659     } catch (...) {
48660       {
48661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48662       };
48663     }
48664   }
48665
48666 }
48667
48668
48669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48670   float jresult ;
48671   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48672   float result;
48673
48674   arg1 = (Dali::CameraActor *)jarg1;
48675   {
48676     try {
48677       result = (float)(arg1)->GetFarClippingPlane();
48678     } catch (std::out_of_range& e) {
48679       {
48680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48681       };
48682     } catch (std::exception& e) {
48683       {
48684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48685       };
48686     } catch (Dali::DaliException e) {
48687       {
48688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48689       };
48690     } catch (...) {
48691       {
48692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48693       };
48694     }
48695   }
48696
48697   jresult = result;
48698   return jresult;
48699 }
48700
48701
48702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48703   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48704   Dali::Vector3 *arg2 = 0 ;
48705
48706   arg1 = (Dali::CameraActor *)jarg1;
48707   arg2 = (Dali::Vector3 *)jarg2;
48708   if (!arg2) {
48709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48710     return ;
48711   }
48712   {
48713     try {
48714       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48715     } catch (std::out_of_range& e) {
48716       {
48717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48718       };
48719     } catch (std::exception& e) {
48720       {
48721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48722       };
48723     } catch (Dali::DaliException e) {
48724       {
48725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48726       };
48727     } catch (...) {
48728       {
48729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48730       };
48731     }
48732   }
48733
48734 }
48735
48736
48737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48738   void * jresult ;
48739   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48740   Dali::Vector3 result;
48741
48742   arg1 = (Dali::CameraActor *)jarg1;
48743   {
48744     try {
48745       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48746     } catch (std::out_of_range& e) {
48747       {
48748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48749       };
48750     } catch (std::exception& e) {
48751       {
48752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48753       };
48754     } catch (Dali::DaliException e) {
48755       {
48756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48757       };
48758     } catch (...) {
48759       {
48760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48761       };
48762     }
48763   }
48764
48765   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48766   return jresult;
48767 }
48768
48769
48770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48771   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48772   bool arg2 ;
48773
48774   arg1 = (Dali::CameraActor *)jarg1;
48775   arg2 = jarg2 ? true : false;
48776   {
48777     try {
48778       (arg1)->SetInvertYAxis(arg2);
48779     } catch (std::out_of_range& e) {
48780       {
48781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48782       };
48783     } catch (std::exception& e) {
48784       {
48785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48786       };
48787     } catch (Dali::DaliException e) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48790       };
48791     } catch (...) {
48792       {
48793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48794       };
48795     }
48796   }
48797
48798 }
48799
48800
48801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48802   unsigned int jresult ;
48803   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48804   bool result;
48805
48806   arg1 = (Dali::CameraActor *)jarg1;
48807   {
48808     try {
48809       result = (bool)(arg1)->GetInvertYAxis();
48810     } catch (std::out_of_range& e) {
48811       {
48812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48813       };
48814     } catch (std::exception& e) {
48815       {
48816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48817       };
48818     } catch (Dali::DaliException e) {
48819       {
48820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48821       };
48822     } catch (...) {
48823       {
48824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48825       };
48826     }
48827   }
48828
48829   jresult = result;
48830   return jresult;
48831 }
48832
48833
48834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48835   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48836   Dali::Size *arg2 = 0 ;
48837
48838   arg1 = (Dali::CameraActor *)jarg1;
48839   arg2 = (Dali::Size *)jarg2;
48840   if (!arg2) {
48841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48842     return ;
48843   }
48844   {
48845     try {
48846       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48847     } catch (std::out_of_range& e) {
48848       {
48849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48850       };
48851     } catch (std::exception& e) {
48852       {
48853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48854       };
48855     } catch (Dali::DaliException e) {
48856       {
48857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48858       };
48859     } catch (...) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48862       };
48863     }
48864   }
48865
48866 }
48867
48868
48869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48870   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48871   Dali::Size *arg2 = 0 ;
48872
48873   arg1 = (Dali::CameraActor *)jarg1;
48874   arg2 = (Dali::Size *)jarg2;
48875   if (!arg2) {
48876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48877     return ;
48878   }
48879   {
48880     try {
48881       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48882     } catch (std::out_of_range& e) {
48883       {
48884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48885       };
48886     } catch (std::exception& e) {
48887       {
48888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48889       };
48890     } catch (Dali::DaliException e) {
48891       {
48892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48893       };
48894     } catch (...) {
48895       {
48896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48897       };
48898     }
48899   }
48900
48901 }
48902
48903
48904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48905   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48906   float arg2 ;
48907   float arg3 ;
48908   float arg4 ;
48909   float arg5 ;
48910   float arg6 ;
48911   float arg7 ;
48912
48913   arg1 = (Dali::CameraActor *)jarg1;
48914   arg2 = (float)jarg2;
48915   arg3 = (float)jarg3;
48916   arg4 = (float)jarg4;
48917   arg5 = (float)jarg5;
48918   arg6 = (float)jarg6;
48919   arg7 = (float)jarg7;
48920   {
48921     try {
48922       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48923     } catch (std::out_of_range& e) {
48924       {
48925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48926       };
48927     } catch (std::exception& e) {
48928       {
48929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48930       };
48931     } catch (Dali::DaliException e) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48934       };
48935     } catch (...) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48938       };
48939     }
48940   }
48941
48942 }
48943
48944
48945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48946   void * jresult ;
48947   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48948
48949   {
48950     try {
48951       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48952     } catch (std::out_of_range& e) {
48953       {
48954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48955       };
48956     } catch (std::exception& e) {
48957       {
48958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48959       };
48960     } catch (Dali::DaliException e) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48963       };
48964     } catch (...) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48967       };
48968     }
48969   }
48970
48971   jresult = (void *)result;
48972   return jresult;
48973 }
48974
48975
48976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
48977   void * jresult ;
48978   std::string arg1 ;
48979   Dali::Property::Value arg2 ;
48980   Dali::Property::Value *argp2 ;
48981   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48982
48983   if (!jarg1) {
48984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48985     return 0;
48986   }
48987   (&arg1)->assign(jarg1);
48988   argp2 = (Dali::Property::Value *)jarg2;
48989   if (!argp2) {
48990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
48991     return 0;
48992   }
48993   arg2 = *argp2;
48994   {
48995     try {
48996       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49012       };
49013     }
49014   }
49015
49016   jresult = (void *)result;
49017   return jresult;
49018 }
49019
49020
49021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49022   void * jresult ;
49023   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49024   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49025
49026   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49027   if (!arg1) {
49028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49029     return 0;
49030   }
49031   {
49032     try {
49033       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);
49034     } catch (std::out_of_range& e) {
49035       {
49036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49037       };
49038     } catch (std::exception& e) {
49039       {
49040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49041       };
49042     } catch (Dali::DaliException e) {
49043       {
49044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49045       };
49046     } catch (...) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49049       };
49050     }
49051   }
49052
49053   jresult = (void *)result;
49054   return jresult;
49055 }
49056
49057
49058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49059   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49060   std::string *arg2 = 0 ;
49061
49062   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49063   if (!jarg2) {
49064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49065     return ;
49066   }
49067   std::string arg2_str(jarg2);
49068   arg2 = &arg2_str;
49069   if (arg1) (arg1)->first = *arg2;
49070
49071   //argout typemap for const std::string&
49072
49073 }
49074
49075
49076 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49077   char * jresult ;
49078   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49079   std::string *result = 0 ;
49080
49081   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49082   result = (std::string *) & ((arg1)->first);
49083   jresult = SWIG_csharp_string_callback(result->c_str());
49084   return jresult;
49085 }
49086
49087
49088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49089   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49090   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49091
49092   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49093   arg2 = (Dali::Property::Value *)jarg2;
49094   if (arg1) (arg1)->second = *arg2;
49095 }
49096
49097
49098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49099   void * jresult ;
49100   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49101   Dali::Property::Value *result = 0 ;
49102
49103   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49104   result = (Dali::Property::Value *)& ((arg1)->second);
49105   jresult = (void *)result;
49106   return jresult;
49107 }
49108
49109
49110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49111   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49112
49113   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49114   {
49115     try {
49116       delete arg1;
49117     } catch (std::out_of_range& e) {
49118       {
49119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49120       };
49121     } catch (std::exception& e) {
49122       {
49123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49124       };
49125     } catch (Dali::DaliException e) {
49126       {
49127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49128       };
49129     } catch (...) {
49130       {
49131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49132       };
49133     }
49134   }
49135
49136 }
49137
49138
49139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49140   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49141
49142   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49143   {
49144     try {
49145       (arg1)->clear();
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49153       };
49154     } catch (Dali::DaliException e) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49161       };
49162     }
49163   }
49164
49165 }
49166
49167
49168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49169   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49170   Dali::TouchPoint *arg2 = 0 ;
49171
49172   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49173   arg2 = (Dali::TouchPoint *)jarg2;
49174   if (!arg2) {
49175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49176     return ;
49177   }
49178   {
49179     try {
49180       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49181     } catch (std::out_of_range& e) {
49182       {
49183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49184       };
49185     } catch (std::exception& e) {
49186       {
49187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49188       };
49189     } catch (Dali::DaliException e) {
49190       {
49191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49192       };
49193     } catch (...) {
49194       {
49195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49196       };
49197     }
49198   }
49199
49200 }
49201
49202
49203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49204   unsigned long jresult ;
49205   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49206   std::vector< Dali::TouchPoint >::size_type result;
49207
49208   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49209   {
49210     try {
49211       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49212     } catch (std::out_of_range& e) {
49213       {
49214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49215       };
49216     } catch (std::exception& e) {
49217       {
49218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49219       };
49220     } catch (Dali::DaliException e) {
49221       {
49222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49223       };
49224     } catch (...) {
49225       {
49226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49227       };
49228     }
49229   }
49230
49231   jresult = (unsigned long)result;
49232   return jresult;
49233 }
49234
49235
49236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49237   unsigned long jresult ;
49238   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49239   std::vector< Dali::TouchPoint >::size_type result;
49240
49241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49242   {
49243     try {
49244       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49245     } catch (std::out_of_range& e) {
49246       {
49247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49248       };
49249     } catch (std::exception& e) {
49250       {
49251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49252       };
49253     } catch (Dali::DaliException e) {
49254       {
49255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49260       };
49261     }
49262   }
49263
49264   jresult = (unsigned long)result;
49265   return jresult;
49266 }
49267
49268
49269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49270   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49271   std::vector< Dali::TouchPoint >::size_type arg2 ;
49272
49273   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49274   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49275   {
49276     try {
49277       (arg1)->reserve(arg2);
49278     } catch (std::out_of_range& e) {
49279       {
49280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49281       };
49282     } catch (std::exception& e) {
49283       {
49284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49285       };
49286     } catch (Dali::DaliException e) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49293       };
49294     }
49295   }
49296
49297 }
49298
49299
49300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49301   void * jresult ;
49302   std::vector< Dali::TouchPoint > *result = 0 ;
49303
49304   {
49305     try {
49306       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49307     } catch (std::out_of_range& e) {
49308       {
49309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49310       };
49311     } catch (std::exception& e) {
49312       {
49313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49314       };
49315     } catch (Dali::DaliException e) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49322       };
49323     }
49324   }
49325
49326   jresult = (void *)result;
49327   return jresult;
49328 }
49329
49330
49331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49332   void * jresult ;
49333   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49334   std::vector< Dali::TouchPoint > *result = 0 ;
49335
49336   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49337   if (!arg1) {
49338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49339     return 0;
49340   }
49341   {
49342     try {
49343       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49344     } catch (std::out_of_range& e) {
49345       {
49346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49347       };
49348     } catch (std::exception& e) {
49349       {
49350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49351       };
49352     } catch (Dali::DaliException e) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49355       };
49356     } catch (...) {
49357       {
49358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49359       };
49360     }
49361   }
49362
49363   jresult = (void *)result;
49364   return jresult;
49365 }
49366
49367
49368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49369   void * jresult ;
49370   int arg1 ;
49371   std::vector< Dali::TouchPoint > *result = 0 ;
49372
49373   arg1 = (int)jarg1;
49374   {
49375     try {
49376       try {
49377         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49378       }
49379       catch(std::out_of_range &_e) {
49380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49381         return 0;
49382       }
49383
49384     } catch (std::out_of_range& e) {
49385       {
49386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49387       };
49388     } catch (std::exception& e) {
49389       {
49390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49391       };
49392     } catch (Dali::DaliException e) {
49393       {
49394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49395       };
49396     } catch (...) {
49397       {
49398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49399       };
49400     }
49401   }
49402
49403   jresult = (void *)result;
49404   return jresult;
49405 }
49406
49407
49408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49409   void * jresult ;
49410   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49411   int arg2 ;
49412   SwigValueWrapper< Dali::TouchPoint > result;
49413
49414   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49415   arg2 = (int)jarg2;
49416   {
49417     try {
49418       try {
49419         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49420       }
49421       catch(std::out_of_range &_e) {
49422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49423         return 0;
49424       }
49425
49426     } catch (std::out_of_range& e) {
49427       {
49428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (std::exception& e) {
49431       {
49432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49433       };
49434     } catch (Dali::DaliException e) {
49435       {
49436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49437       };
49438     } catch (...) {
49439       {
49440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49441       };
49442     }
49443   }
49444
49445   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49446   return jresult;
49447 }
49448
49449
49450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49451   void * jresult ;
49452   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49453   int arg2 ;
49454   Dali::TouchPoint *result = 0 ;
49455
49456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49457   arg2 = (int)jarg2;
49458   {
49459     try {
49460       try {
49461         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49462       }
49463       catch(std::out_of_range &_e) {
49464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49465         return 0;
49466       }
49467
49468     } catch (std::out_of_range& e) {
49469       {
49470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49471       };
49472     } catch (std::exception& e) {
49473       {
49474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49475       };
49476     } catch (Dali::DaliException e) {
49477       {
49478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49479       };
49480     } catch (...) {
49481       {
49482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49483       };
49484     }
49485   }
49486
49487   jresult = (void *)result;
49488   return jresult;
49489 }
49490
49491
49492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49493   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49494   int arg2 ;
49495   Dali::TouchPoint *arg3 = 0 ;
49496
49497   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49498   arg2 = (int)jarg2;
49499   arg3 = (Dali::TouchPoint *)jarg3;
49500   if (!arg3) {
49501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49502     return ;
49503   }
49504   {
49505     try {
49506       try {
49507         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49508       }
49509       catch(std::out_of_range &_e) {
49510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49511         return ;
49512       }
49513
49514     } catch (std::out_of_range& e) {
49515       {
49516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49517       };
49518     } catch (std::exception& e) {
49519       {
49520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49521       };
49522     } catch (Dali::DaliException e) {
49523       {
49524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49525       };
49526     } catch (...) {
49527       {
49528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49529       };
49530     }
49531   }
49532
49533 }
49534
49535
49536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49537   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49538   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49539
49540   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49541   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49542   if (!arg2) {
49543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49544     return ;
49545   }
49546   {
49547     try {
49548       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49549     } catch (std::out_of_range& e) {
49550       {
49551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49552       };
49553     } catch (std::exception& e) {
49554       {
49555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49556       };
49557     } catch (Dali::DaliException e) {
49558       {
49559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49560       };
49561     } catch (...) {
49562       {
49563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49564       };
49565     }
49566   }
49567
49568 }
49569
49570
49571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49572   void * jresult ;
49573   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49574   int arg2 ;
49575   int arg3 ;
49576   std::vector< Dali::TouchPoint > *result = 0 ;
49577
49578   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49579   arg2 = (int)jarg2;
49580   arg3 = (int)jarg3;
49581   {
49582     try {
49583       try {
49584         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49585       }
49586       catch(std::out_of_range &_e) {
49587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49588         return 0;
49589       }
49590       catch(std::invalid_argument &_e) {
49591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49592         return 0;
49593       }
49594
49595     } catch (std::out_of_range& e) {
49596       {
49597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49598       };
49599     } catch (std::exception& e) {
49600       {
49601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49602       };
49603     } catch (Dali::DaliException e) {
49604       {
49605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49606       };
49607     } catch (...) {
49608       {
49609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49610       };
49611     }
49612   }
49613
49614   jresult = (void *)result;
49615   return jresult;
49616 }
49617
49618
49619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49620   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49621   int arg2 ;
49622   Dali::TouchPoint *arg3 = 0 ;
49623
49624   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49625   arg2 = (int)jarg2;
49626   arg3 = (Dali::TouchPoint *)jarg3;
49627   if (!arg3) {
49628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49629     return ;
49630   }
49631   {
49632     try {
49633       try {
49634         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49635       }
49636       catch(std::out_of_range &_e) {
49637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49638         return ;
49639       }
49640
49641     } catch (std::out_of_range& e) {
49642       {
49643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49644       };
49645     } catch (std::exception& e) {
49646       {
49647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49648       };
49649     } catch (Dali::DaliException e) {
49650       {
49651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49652       };
49653     } catch (...) {
49654       {
49655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49656       };
49657     }
49658   }
49659
49660 }
49661
49662
49663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49664   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49665   int arg2 ;
49666   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49667
49668   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49669   arg2 = (int)jarg2;
49670   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49671   if (!arg3) {
49672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49673     return ;
49674   }
49675   {
49676     try {
49677       try {
49678         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49679       }
49680       catch(std::out_of_range &_e) {
49681         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49682         return ;
49683       }
49684
49685     } catch (std::out_of_range& e) {
49686       {
49687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49688       };
49689     } catch (std::exception& e) {
49690       {
49691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49692       };
49693     } catch (Dali::DaliException e) {
49694       {
49695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49696       };
49697     } catch (...) {
49698       {
49699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49700       };
49701     }
49702   }
49703
49704 }
49705
49706
49707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49708   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49709   int arg2 ;
49710
49711   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49712   arg2 = (int)jarg2;
49713   {
49714     try {
49715       try {
49716         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49717       }
49718       catch(std::out_of_range &_e) {
49719         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49720         return ;
49721       }
49722
49723     } catch (std::out_of_range& e) {
49724       {
49725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49726       };
49727     } catch (std::exception& e) {
49728       {
49729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49730       };
49731     } catch (Dali::DaliException e) {
49732       {
49733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49734       };
49735     } catch (...) {
49736       {
49737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49738       };
49739     }
49740   }
49741
49742 }
49743
49744
49745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49746   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49747   int arg2 ;
49748   int arg3 ;
49749
49750   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49751   arg2 = (int)jarg2;
49752   arg3 = (int)jarg3;
49753   {
49754     try {
49755       try {
49756         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49757       }
49758       catch(std::out_of_range &_e) {
49759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49760         return ;
49761       }
49762       catch(std::invalid_argument &_e) {
49763         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49764         return ;
49765       }
49766
49767     } catch (std::out_of_range& e) {
49768       {
49769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49770       };
49771     } catch (std::exception& e) {
49772       {
49773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49774       };
49775     } catch (Dali::DaliException e) {
49776       {
49777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49778       };
49779     } catch (...) {
49780       {
49781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49782       };
49783     }
49784   }
49785
49786 }
49787
49788
49789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49790   void * jresult ;
49791   Dali::TouchPoint *arg1 = 0 ;
49792   int arg2 ;
49793   std::vector< Dali::TouchPoint > *result = 0 ;
49794
49795   arg1 = (Dali::TouchPoint *)jarg1;
49796   if (!arg1) {
49797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49798     return 0;
49799   }
49800   arg2 = (int)jarg2;
49801   {
49802     try {
49803       try {
49804         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49805       }
49806       catch(std::out_of_range &_e) {
49807         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49808         return 0;
49809       }
49810
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (Dali::DaliException e) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49822       };
49823     } catch (...) {
49824       {
49825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49826       };
49827     }
49828   }
49829
49830   jresult = (void *)result;
49831   return jresult;
49832 }
49833
49834
49835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49836   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49837
49838   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49839   {
49840     try {
49841       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49842     } catch (std::out_of_range& e) {
49843       {
49844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49845       };
49846     } catch (std::exception& e) {
49847       {
49848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49849       };
49850     } catch (Dali::DaliException e) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49853       };
49854     } catch (...) {
49855       {
49856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49857       };
49858     }
49859   }
49860
49861 }
49862
49863
49864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49865   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49866   int arg2 ;
49867   int arg3 ;
49868
49869   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49870   arg2 = (int)jarg2;
49871   arg3 = (int)jarg3;
49872   {
49873     try {
49874       try {
49875         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49876       }
49877       catch(std::out_of_range &_e) {
49878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49879         return ;
49880       }
49881       catch(std::invalid_argument &_e) {
49882         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49883         return ;
49884       }
49885
49886     } catch (std::out_of_range& e) {
49887       {
49888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49889       };
49890     } catch (std::exception& e) {
49891       {
49892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49893       };
49894     } catch (Dali::DaliException e) {
49895       {
49896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49897       };
49898     } catch (...) {
49899       {
49900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49901       };
49902     }
49903   }
49904
49905 }
49906
49907
49908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49909   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49910   int arg2 ;
49911   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49912
49913   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49914   arg2 = (int)jarg2;
49915   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49916   if (!arg3) {
49917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49918     return ;
49919   }
49920   {
49921     try {
49922       try {
49923         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49924       }
49925       catch(std::out_of_range &_e) {
49926         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49927         return ;
49928       }
49929
49930     } catch (std::out_of_range& e) {
49931       {
49932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49933       };
49934     } catch (std::exception& e) {
49935       {
49936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49937       };
49938     } catch (Dali::DaliException e) {
49939       {
49940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49941       };
49942     } catch (...) {
49943       {
49944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49945       };
49946     }
49947   }
49948
49949 }
49950
49951
49952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49953   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49954
49955   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49956   {
49957     try {
49958       delete arg1;
49959     } catch (std::out_of_range& e) {
49960       {
49961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (std::exception& e) {
49964       {
49965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (Dali::DaliException e) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49970       };
49971     } catch (...) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49974       };
49975     }
49976   }
49977
49978 }
49979
49980
49981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
49982   void * jresult ;
49983   Dali::Rect< int > *result = 0 ;
49984
49985   {
49986     try {
49987       result = (Dali::Rect< int > *)new Dali::Rect< int >();
49988     } catch (std::out_of_range& e) {
49989       {
49990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49991       };
49992     } catch (std::exception& e) {
49993       {
49994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49995       };
49996     } catch (Dali::DaliException e) {
49997       {
49998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49999       };
50000     } catch (...) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50003       };
50004     }
50005   }
50006
50007   jresult = (void *)result;
50008   return jresult;
50009 }
50010
50011
50012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50013   void * jresult ;
50014   int arg1 ;
50015   int arg2 ;
50016   int arg3 ;
50017   int arg4 ;
50018   Dali::Rect< int > *result = 0 ;
50019
50020   arg1 = (int)jarg1;
50021   arg2 = (int)jarg2;
50022   arg3 = (int)jarg3;
50023   arg4 = (int)jarg4;
50024   {
50025     try {
50026       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50027     } catch (std::out_of_range& e) {
50028       {
50029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (std::exception& e) {
50032       {
50033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50034       };
50035     } catch (Dali::DaliException e) {
50036       {
50037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50038       };
50039     } catch (...) {
50040       {
50041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50042       };
50043     }
50044   }
50045
50046   jresult = (void *)result;
50047   return jresult;
50048 }
50049
50050
50051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50052   void * jresult ;
50053   Dali::Rect< int > *arg1 = 0 ;
50054   Dali::Rect< int > *result = 0 ;
50055
50056   arg1 = (Dali::Rect< int > *)jarg1;
50057   if (!arg1) {
50058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50059     return 0;
50060   }
50061   {
50062     try {
50063       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50071       };
50072     } catch (Dali::DaliException e) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50075       };
50076     } catch (...) {
50077       {
50078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50079       };
50080     }
50081   }
50082
50083   jresult = (void *)result;
50084   return jresult;
50085 }
50086
50087
50088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50089   void * jresult ;
50090   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50091   Dali::Rect< int > *arg2 = 0 ;
50092   Dali::Rect< int > *result = 0 ;
50093
50094   arg1 = (Dali::Rect< int > *)jarg1;
50095   arg2 = (Dali::Rect< int > *)jarg2;
50096   if (!arg2) {
50097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50098     return 0;
50099   }
50100   {
50101     try {
50102       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50110       };
50111     } catch (Dali::DaliException e) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50114       };
50115     } catch (...) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50118       };
50119     }
50120   }
50121
50122   jresult = (void *)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50128   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50129   int arg2 ;
50130   int arg3 ;
50131   int arg4 ;
50132   int arg5 ;
50133
50134   arg1 = (Dali::Rect< int > *)jarg1;
50135   arg2 = (int)jarg2;
50136   arg3 = (int)jarg3;
50137   arg4 = (int)jarg4;
50138   arg5 = (int)jarg5;
50139   {
50140     try {
50141       (arg1)->Set(arg2,arg3,arg4,arg5);
50142     } catch (std::out_of_range& e) {
50143       {
50144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50145       };
50146     } catch (std::exception& e) {
50147       {
50148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50149       };
50150     } catch (Dali::DaliException e) {
50151       {
50152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50153       };
50154     } catch (...) {
50155       {
50156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50157       };
50158     }
50159   }
50160
50161 }
50162
50163
50164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50165   unsigned int jresult ;
50166   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50167   bool result;
50168
50169   arg1 = (Dali::Rect< int > *)jarg1;
50170   {
50171     try {
50172       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50173     } catch (std::out_of_range& e) {
50174       {
50175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50176       };
50177     } catch (std::exception& e) {
50178       {
50179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50180       };
50181     } catch (Dali::DaliException e) {
50182       {
50183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50184       };
50185     } catch (...) {
50186       {
50187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50188       };
50189     }
50190   }
50191
50192   jresult = result;
50193   return jresult;
50194 }
50195
50196
50197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50198   int jresult ;
50199   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50200   int result;
50201
50202   arg1 = (Dali::Rect< int > *)jarg1;
50203   {
50204     try {
50205       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50206     } catch (std::out_of_range& e) {
50207       {
50208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (std::exception& e) {
50211       {
50212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50213       };
50214     } catch (Dali::DaliException e) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50217       };
50218     } catch (...) {
50219       {
50220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50221       };
50222     }
50223   }
50224
50225   jresult = result;
50226   return jresult;
50227 }
50228
50229
50230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50231   int jresult ;
50232   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50233   int result;
50234
50235   arg1 = (Dali::Rect< int > *)jarg1;
50236   {
50237     try {
50238       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50239     } catch (std::out_of_range& e) {
50240       {
50241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (std::exception& e) {
50244       {
50245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50246       };
50247     } catch (Dali::DaliException e) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50250       };
50251     } catch (...) {
50252       {
50253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50254       };
50255     }
50256   }
50257
50258   jresult = result;
50259   return jresult;
50260 }
50261
50262
50263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50264   int jresult ;
50265   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50266   int result;
50267
50268   arg1 = (Dali::Rect< int > *)jarg1;
50269   {
50270     try {
50271       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50272     } catch (std::out_of_range& e) {
50273       {
50274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (std::exception& e) {
50277       {
50278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50279       };
50280     } catch (Dali::DaliException e) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50283       };
50284     } catch (...) {
50285       {
50286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50287       };
50288     }
50289   }
50290
50291   jresult = result;
50292   return jresult;
50293 }
50294
50295
50296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50297   int jresult ;
50298   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50299   int result;
50300
50301   arg1 = (Dali::Rect< int > *)jarg1;
50302   {
50303     try {
50304       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50305     } catch (std::out_of_range& e) {
50306       {
50307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (std::exception& e) {
50310       {
50311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50312       };
50313     } catch (Dali::DaliException e) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50316       };
50317     } catch (...) {
50318       {
50319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50320       };
50321     }
50322   }
50323
50324   jresult = result;
50325   return jresult;
50326 }
50327
50328
50329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50330   int jresult ;
50331   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50332   int result;
50333
50334   arg1 = (Dali::Rect< int > *)jarg1;
50335   {
50336     try {
50337       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50345       };
50346     } catch (Dali::DaliException e) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50349       };
50350     } catch (...) {
50351       {
50352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50353       };
50354     }
50355   }
50356
50357   jresult = result;
50358   return jresult;
50359 }
50360
50361
50362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50363   unsigned int jresult ;
50364   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50365   Dali::Rect< int > *arg2 = 0 ;
50366   bool result;
50367
50368   arg1 = (Dali::Rect< int > *)jarg1;
50369   arg2 = (Dali::Rect< int > *)jarg2;
50370   if (!arg2) {
50371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50372     return 0;
50373   }
50374   {
50375     try {
50376       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50377     } catch (std::out_of_range& e) {
50378       {
50379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50380       };
50381     } catch (std::exception& e) {
50382       {
50383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50384       };
50385     } catch (Dali::DaliException e) {
50386       {
50387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50388       };
50389     } catch (...) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50392       };
50393     }
50394   }
50395
50396   jresult = result;
50397   return jresult;
50398 }
50399
50400
50401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50402   unsigned int jresult ;
50403   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50404   Dali::Rect< int > *arg2 = 0 ;
50405   bool result;
50406
50407   arg1 = (Dali::Rect< int > *)jarg1;
50408   arg2 = (Dali::Rect< int > *)jarg2;
50409   if (!arg2) {
50410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50411     return 0;
50412   }
50413   {
50414     try {
50415       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50416     } catch (std::out_of_range& e) {
50417       {
50418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50419       };
50420     } catch (std::exception& e) {
50421       {
50422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50423       };
50424     } catch (Dali::DaliException e) {
50425       {
50426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50427       };
50428     } catch (...) {
50429       {
50430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50431       };
50432     }
50433   }
50434
50435   jresult = result;
50436   return jresult;
50437 }
50438
50439
50440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50441   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50442   int arg2 ;
50443
50444   arg1 = (Dali::Rect< int > *)jarg1;
50445   arg2 = (int)jarg2;
50446   if (arg1) (arg1)->x = arg2;
50447 }
50448
50449
50450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50451   int jresult ;
50452   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50453   int result;
50454
50455   arg1 = (Dali::Rect< int > *)jarg1;
50456   result = (int) ((arg1)->x);
50457   jresult = result;
50458   return jresult;
50459 }
50460
50461
50462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50463   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50464   int arg2 ;
50465
50466   arg1 = (Dali::Rect< int > *)jarg1;
50467   arg2 = (int)jarg2;
50468   if (arg1) (arg1)->left = arg2;
50469 }
50470
50471
50472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50473   int jresult ;
50474   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50475   int result;
50476
50477   arg1 = (Dali::Rect< int > *)jarg1;
50478   result = (int) ((arg1)->left);
50479   jresult = result;
50480   return jresult;
50481 }
50482
50483
50484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50486   int arg2 ;
50487
50488   arg1 = (Dali::Rect< int > *)jarg1;
50489   arg2 = (int)jarg2;
50490   if (arg1) (arg1)->y = arg2;
50491 }
50492
50493
50494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50495   int jresult ;
50496   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50497   int result;
50498
50499   arg1 = (Dali::Rect< int > *)jarg1;
50500   result = (int) ((arg1)->y);
50501   jresult = result;
50502   return jresult;
50503 }
50504
50505
50506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50507   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50508   int arg2 ;
50509
50510   arg1 = (Dali::Rect< int > *)jarg1;
50511   arg2 = (int)jarg2;
50512   if (arg1) (arg1)->right = arg2;
50513 }
50514
50515
50516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50517   int jresult ;
50518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50519   int result;
50520
50521   arg1 = (Dali::Rect< int > *)jarg1;
50522   result = (int) ((arg1)->right);
50523   jresult = result;
50524   return jresult;
50525 }
50526
50527
50528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50529   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50530   int arg2 ;
50531
50532   arg1 = (Dali::Rect< int > *)jarg1;
50533   arg2 = (int)jarg2;
50534   if (arg1) (arg1)->width = arg2;
50535 }
50536
50537
50538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50539   int jresult ;
50540   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50541   int result;
50542
50543   arg1 = (Dali::Rect< int > *)jarg1;
50544   result = (int) ((arg1)->width);
50545   jresult = result;
50546   return jresult;
50547 }
50548
50549
50550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50551   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50552   int arg2 ;
50553
50554   arg1 = (Dali::Rect< int > *)jarg1;
50555   arg2 = (int)jarg2;
50556   if (arg1) (arg1)->bottom = arg2;
50557 }
50558
50559
50560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50561   int jresult ;
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int result;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   result = (int) ((arg1)->bottom);
50567   jresult = result;
50568   return jresult;
50569 }
50570
50571
50572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int arg2 ;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   arg2 = (int)jarg2;
50578   if (arg1) (arg1)->height = arg2;
50579 }
50580
50581
50582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50583   int jresult ;
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int result;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   result = (int) ((arg1)->height);
50589   jresult = result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int arg2 ;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   arg2 = (int)jarg2;
50600   if (arg1) (arg1)->top = arg2;
50601 }
50602
50603
50604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50605   int jresult ;
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int result;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   result = (int) ((arg1)->top);
50611   jresult = result;
50612   return jresult;
50613 }
50614
50615
50616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618
50619   arg1 = (Dali::Rect< int > *)jarg1;
50620   {
50621     try {
50622       delete arg1;
50623     } catch (std::out_of_range& e) {
50624       {
50625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50626       };
50627     } catch (std::exception& e) {
50628       {
50629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50630       };
50631     } catch (Dali::DaliException e) {
50632       {
50633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50634       };
50635     } catch (...) {
50636       {
50637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50638       };
50639     }
50640   }
50641
50642 }
50643
50644
50645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50646   void * jresult ;
50647   Dali::Rect< float > *result = 0 ;
50648
50649   {
50650     try {
50651       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50659       };
50660     } catch (Dali::DaliException e) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50667       };
50668     }
50669   }
50670
50671   jresult = (void *)result;
50672   return jresult;
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50677   void * jresult ;
50678   float arg1 ;
50679   float arg2 ;
50680   float arg3 ;
50681   float arg4 ;
50682   Dali::Rect< float > *result = 0 ;
50683
50684   arg1 = (float)jarg1;
50685   arg2 = (float)jarg2;
50686   arg3 = (float)jarg4;
50687   arg4 = (float)jarg3;
50688   {
50689     try {
50690       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50691     } catch (std::out_of_range& e) {
50692       {
50693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50694       };
50695     } catch (std::exception& e) {
50696       {
50697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50698       };
50699     } catch (Dali::DaliException e) {
50700       {
50701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50702       };
50703     } catch (...) {
50704       {
50705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50706       };
50707     }
50708   }
50709
50710   jresult = (void *)result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50716   void * jresult ;
50717   Dali::Rect< float > *arg1 = 0 ;
50718   Dali::Rect< float > *result = 0 ;
50719
50720   arg1 = (Dali::Rect< float > *)jarg1;
50721   if (!arg1) {
50722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50723     return 0;
50724   }
50725   {
50726     try {
50727       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50728     } catch (std::out_of_range& e) {
50729       {
50730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50731       };
50732     } catch (std::exception& e) {
50733       {
50734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50735       };
50736     } catch (Dali::DaliException e) {
50737       {
50738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50739       };
50740     } catch (...) {
50741       {
50742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50743       };
50744     }
50745   }
50746
50747   jresult = (void *)result;
50748   return jresult;
50749 }
50750
50751
50752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50753   void * jresult ;
50754   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50755   Dali::Rect< float > *arg2 = 0 ;
50756   Dali::Rect< float > *result = 0 ;
50757
50758   arg1 = (Dali::Rect< float > *)jarg1;
50759   arg2 = (Dali::Rect< float > *)jarg2;
50760   if (!arg2) {
50761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50762     return 0;
50763   }
50764   {
50765     try {
50766       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (Dali::DaliException e) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50778       };
50779     } catch (...) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50782       };
50783     }
50784   }
50785
50786   jresult = (void *)result;
50787   return jresult;
50788 }
50789
50790
50791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50792   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50793   float arg2 ;
50794   float arg3 ;
50795   float arg4 ;
50796   float arg5 ;
50797
50798   arg1 = (Dali::Rect< float > *)jarg1;
50799   arg2 = (float)jarg2;
50800   arg3 = (float)jarg3;
50801   arg4 = (float)jarg5;
50802   arg5 = (float)jarg4;
50803   {
50804     try {
50805       (arg1)->Set(arg2,arg3,arg4,arg5);
50806     } catch (std::out_of_range& e) {
50807       {
50808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50809       };
50810     } catch (std::exception& e) {
50811       {
50812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50813       };
50814     } catch (Dali::DaliException e) {
50815       {
50816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50817       };
50818     } catch (...) {
50819       {
50820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50821       };
50822     }
50823   }
50824
50825 }
50826
50827
50828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50829   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50830   float arg2 ;
50831
50832   arg1 = (Dali::Rect< float > *)jarg1;
50833   arg2 = (float)jarg2;
50834   if (arg1) (arg1)->left = arg2;
50835 }
50836
50837
50838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50839   float jresult ;
50840   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50841   float result;
50842
50843   arg1 = (Dali::Rect< float > *)jarg1;
50844   result = (float) ((arg1)->left);
50845   jresult = result;
50846   return jresult;
50847 }
50848
50849
50850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50851   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50852   float arg2 ;
50853
50854   arg1 = (Dali::Rect< float > *)jarg1;
50855   arg2 = (float)jarg2;
50856   if (arg1) (arg1)->left = arg2;
50857 }
50858
50859
50860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50861   float jresult ;
50862   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50863   float result;
50864
50865   arg1 = (Dali::Rect< float > *)jarg1;
50866   result = (float) ((arg1)->left);
50867   jresult = result;
50868   return jresult;
50869 }
50870
50871
50872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50873   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50874   float arg2 ;
50875
50876   arg1 = (Dali::Rect< float > *)jarg1;
50877   arg2 = (float)jarg2;
50878   if (arg1) (arg1)->right = arg2;
50879 }
50880
50881
50882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50883   float jresult ;
50884   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50885   float result;
50886
50887   arg1 = (Dali::Rect< float > *)jarg1;
50888   result = (float) ((arg1)->right);
50889   jresult = result;
50890   return jresult;
50891 }
50892
50893
50894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50895   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50896   float arg2 ;
50897
50898   arg1 = (Dali::Rect< float > *)jarg1;
50899   arg2 = (float)jarg2;
50900   if (arg1) (arg1)->right = arg2;
50901 }
50902
50903
50904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50905   float jresult ;
50906   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50907   float result;
50908
50909   arg1 = (Dali::Rect< float > *)jarg1;
50910   result = (float) ((arg1)->right);
50911   jresult = result;
50912   return jresult;
50913 }
50914
50915
50916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50917   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50918   float arg2 ;
50919
50920   arg1 = (Dali::Rect< float > *)jarg1;
50921   arg2 = (float)jarg2;
50922   if (arg1) (arg1)->bottom = arg2;
50923 }
50924
50925
50926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50927   float jresult ;
50928   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50929   float result;
50930
50931   arg1 = (Dali::Rect< float > *)jarg1;
50932   result = (float) ((arg1)->bottom);
50933   jresult = result;
50934   return jresult;
50935 }
50936
50937
50938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50939   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50940   float arg2 ;
50941
50942   arg1 = (Dali::Rect< float > *)jarg1;
50943   arg2 = (float)jarg2;
50944   if (arg1) (arg1)->top = arg2;
50945 }
50946
50947
50948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50949   float jresult ;
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float result;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   result = (float) ((arg1)->top);
50955   jresult = result;
50956   return jresult;
50957 }
50958
50959
50960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962
50963   arg1 = (Dali::Rect< float > *)jarg1;
50964   {
50965     try {
50966       delete arg1;
50967     } catch (std::out_of_range& e) {
50968       {
50969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50970       };
50971     } catch (std::exception& e) {
50972       {
50973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50974       };
50975     } catch (Dali::DaliException e) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50978       };
50979     } catch (...) {
50980       {
50981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50982       };
50983     }
50984   }
50985
50986 }
50987
50988
50989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
50990   int jresult ;
50991   int result;
50992
50993   result = (int)Dali::Vector< int >::BaseType;
50994   jresult = (int)result;
50995   return jresult;
50996 }
50997
50998
50999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51000   void * jresult ;
51001   Dali::Vector< int > *result = 0 ;
51002
51003   {
51004     try {
51005       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51006     } catch (std::out_of_range& e) {
51007       {
51008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51009       };
51010     } catch (std::exception& e) {
51011       {
51012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51013       };
51014     } catch (Dali::DaliException e) {
51015       {
51016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51017       };
51018     } catch (...) {
51019       {
51020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51021       };
51022     }
51023   }
51024
51025   jresult = (void *)result;
51026   return jresult;
51027 }
51028
51029
51030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51031   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51032
51033   arg1 = (Dali::Vector< int > *)jarg1;
51034   {
51035     try {
51036       delete arg1;
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51044       };
51045     } catch (Dali::DaliException e) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51048       };
51049     } catch (...) {
51050       {
51051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51052       };
51053     }
51054   }
51055
51056 }
51057
51058
51059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51060   void * jresult ;
51061   Dali::Vector< int > *arg1 = 0 ;
51062   Dali::Vector< int > *result = 0 ;
51063
51064   arg1 = (Dali::Vector< int > *)jarg1;
51065   if (!arg1) {
51066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51067     return 0;
51068   }
51069   {
51070     try {
51071       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51072     } catch (std::out_of_range& e) {
51073       {
51074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51075       };
51076     } catch (std::exception& e) {
51077       {
51078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51079       };
51080     } catch (Dali::DaliException e) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51083       };
51084     } catch (...) {
51085       {
51086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51087       };
51088     }
51089   }
51090
51091   jresult = (void *)result;
51092   return jresult;
51093 }
51094
51095
51096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51097   void * jresult ;
51098   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51099   Dali::Vector< int > *arg2 = 0 ;
51100   Dali::Vector< int > *result = 0 ;
51101
51102   arg1 = (Dali::Vector< int > *)jarg1;
51103   arg2 = (Dali::Vector< int > *)jarg2;
51104   if (!arg2) {
51105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51106     return 0;
51107   }
51108   {
51109     try {
51110       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51111     } catch (std::out_of_range& e) {
51112       {
51113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51114       };
51115     } catch (std::exception& e) {
51116       {
51117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51118       };
51119     } catch (Dali::DaliException e) {
51120       {
51121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51122       };
51123     } catch (...) {
51124       {
51125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51126       };
51127     }
51128   }
51129
51130   jresult = (void *)result;
51131   return jresult;
51132 }
51133
51134
51135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51136   void * jresult ;
51137   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51138   Dali::Vector< int >::Iterator result;
51139
51140   arg1 = (Dali::Vector< int > *)jarg1;
51141   {
51142     try {
51143       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51144     } catch (std::out_of_range& e) {
51145       {
51146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (std::exception& e) {
51149       {
51150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (Dali::DaliException e) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51155       };
51156     } catch (...) {
51157       {
51158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51159       };
51160     }
51161   }
51162
51163   jresult = (void *)result;
51164   return jresult;
51165 }
51166
51167
51168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51169   void * jresult ;
51170   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51171   Dali::Vector< int >::Iterator result;
51172
51173   arg1 = (Dali::Vector< int > *)jarg1;
51174   {
51175     try {
51176       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51177     } catch (std::out_of_range& e) {
51178       {
51179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (std::exception& e) {
51182       {
51183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51184       };
51185     } catch (Dali::DaliException e) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51188       };
51189     } catch (...) {
51190       {
51191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51192       };
51193     }
51194   }
51195
51196   jresult = (void *)result;
51197   return jresult;
51198 }
51199
51200
51201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51202   void * jresult ;
51203   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51204   Dali::Vector< int >::SizeType arg2 ;
51205   Dali::Vector< int >::ItemType *result = 0 ;
51206
51207   arg1 = (Dali::Vector< int > *)jarg1;
51208   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51209   {
51210     try {
51211       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51212     } catch (std::out_of_range& e) {
51213       {
51214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51215       };
51216     } catch (std::exception& e) {
51217       {
51218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51219       };
51220     } catch (Dali::DaliException e) {
51221       {
51222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51223       };
51224     } catch (...) {
51225       {
51226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51227       };
51228     }
51229   }
51230
51231   jresult = (void *)result;
51232   return jresult;
51233 }
51234
51235
51236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51237   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51238   Dali::Vector< int >::ItemType *arg2 = 0 ;
51239   Dali::Vector< int >::ItemType temp2 ;
51240
51241   arg1 = (Dali::Vector< int > *)jarg1;
51242   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51243   arg2 = &temp2;
51244   {
51245     try {
51246       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51247     } catch (std::out_of_range& e) {
51248       {
51249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51250       };
51251     } catch (std::exception& e) {
51252       {
51253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51254       };
51255     } catch (Dali::DaliException e) {
51256       {
51257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51258       };
51259     } catch (...) {
51260       {
51261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51262       };
51263     }
51264   }
51265
51266 }
51267
51268
51269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51270   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51271   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51272   Dali::Vector< int >::ItemType *arg3 = 0 ;
51273   Dali::Vector< int >::ItemType temp3 ;
51274
51275   arg1 = (Dali::Vector< int > *)jarg1;
51276   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51277   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51278   arg3 = &temp3;
51279   {
51280     try {
51281       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51282     } catch (std::out_of_range& e) {
51283       {
51284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51285       };
51286     } catch (std::exception& e) {
51287       {
51288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51289       };
51290     } catch (Dali::DaliException e) {
51291       {
51292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51293       };
51294     } catch (...) {
51295       {
51296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51297       };
51298     }
51299   }
51300
51301 }
51302
51303
51304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51305   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51306   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51307   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51308   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51309
51310   arg1 = (Dali::Vector< int > *)jarg1;
51311   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51312   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51313   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51314   {
51315     try {
51316       (arg1)->Insert(arg2,arg3,arg4);
51317     } catch (std::out_of_range& e) {
51318       {
51319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51320       };
51321     } catch (std::exception& e) {
51322       {
51323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51324       };
51325     } catch (Dali::DaliException e) {
51326       {
51327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51328       };
51329     } catch (...) {
51330       {
51331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51332       };
51333     }
51334   }
51335
51336 }
51337
51338
51339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51340   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51341   Dali::Vector< int >::SizeType arg2 ;
51342
51343   arg1 = (Dali::Vector< int > *)jarg1;
51344   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51345   {
51346     try {
51347       (arg1)->Reserve(arg2);
51348     } catch (std::out_of_range& e) {
51349       {
51350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51351       };
51352     } catch (std::exception& e) {
51353       {
51354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51355       };
51356     } catch (Dali::DaliException e) {
51357       {
51358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51359       };
51360     } catch (...) {
51361       {
51362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51363       };
51364     }
51365   }
51366
51367 }
51368
51369
51370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51371   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51372   Dali::Vector< int >::SizeType arg2 ;
51373
51374   arg1 = (Dali::Vector< int > *)jarg1;
51375   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51376   {
51377     try {
51378       (arg1)->Resize(arg2);
51379     } catch (std::out_of_range& e) {
51380       {
51381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51382       };
51383     } catch (std::exception& e) {
51384       {
51385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51386       };
51387     } catch (Dali::DaliException e) {
51388       {
51389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51390       };
51391     } catch (...) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51394       };
51395     }
51396   }
51397
51398 }
51399
51400
51401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51402   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51403   Dali::Vector< int >::SizeType arg2 ;
51404   Dali::Vector< int >::ItemType *arg3 = 0 ;
51405   Dali::Vector< int >::ItemType temp3 ;
51406
51407   arg1 = (Dali::Vector< int > *)jarg1;
51408   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51409   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51410   arg3 = &temp3;
51411   {
51412     try {
51413       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51414     } catch (std::out_of_range& e) {
51415       {
51416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51417       };
51418     } catch (std::exception& e) {
51419       {
51420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (Dali::DaliException e) {
51423       {
51424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51425       };
51426     } catch (...) {
51427       {
51428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51429       };
51430     }
51431   }
51432
51433 }
51434
51435
51436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51437   void * jresult ;
51438   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51439   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51440   Dali::Vector< int >::Iterator result;
51441
51442   arg1 = (Dali::Vector< int > *)jarg1;
51443   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51444   {
51445     try {
51446       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51447     } catch (std::out_of_range& e) {
51448       {
51449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51450       };
51451     } catch (std::exception& e) {
51452       {
51453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51454       };
51455     } catch (Dali::DaliException e) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51458       };
51459     } catch (...) {
51460       {
51461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51462       };
51463     }
51464   }
51465
51466   jresult = (void *)result;
51467   return jresult;
51468 }
51469
51470
51471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51472   void * jresult ;
51473   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51474   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51475   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51476   Dali::Vector< int >::Iterator result;
51477
51478   arg1 = (Dali::Vector< int > *)jarg1;
51479   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51480   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51481   {
51482     try {
51483       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51484     } catch (std::out_of_range& e) {
51485       {
51486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51487       };
51488     } catch (std::exception& e) {
51489       {
51490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51491       };
51492     } catch (Dali::DaliException e) {
51493       {
51494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51499       };
51500     }
51501   }
51502
51503   jresult = (void *)result;
51504   return jresult;
51505 }
51506
51507
51508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51509   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51510   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51511
51512   arg1 = (Dali::Vector< int > *)jarg1;
51513   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51514   {
51515     try {
51516       (arg1)->Remove(arg2);
51517     } catch (std::out_of_range& e) {
51518       {
51519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51520       };
51521     } catch (std::exception& e) {
51522       {
51523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51524       };
51525     } catch (Dali::DaliException e) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51532       };
51533     }
51534   }
51535
51536 }
51537
51538
51539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51540   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51541   Dali::Vector< int > *arg2 = 0 ;
51542
51543   arg1 = (Dali::Vector< int > *)jarg1;
51544   arg2 = (Dali::Vector< int > *)jarg2;
51545   if (!arg2) {
51546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51547     return ;
51548   }
51549   {
51550     try {
51551       (arg1)->Swap(*arg2);
51552     } catch (std::out_of_range& e) {
51553       {
51554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51555       };
51556     } catch (std::exception& e) {
51557       {
51558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51559       };
51560     } catch (Dali::DaliException e) {
51561       {
51562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51563       };
51564     } catch (...) {
51565       {
51566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51567       };
51568     }
51569   }
51570
51571 }
51572
51573
51574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51575   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51576
51577   arg1 = (Dali::Vector< int > *)jarg1;
51578   {
51579     try {
51580       (arg1)->Clear();
51581     } catch (std::out_of_range& e) {
51582       {
51583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (std::exception& e) {
51586       {
51587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (Dali::DaliException e) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51592       };
51593     } catch (...) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51596       };
51597     }
51598   }
51599
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51604   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51605
51606   arg1 = (Dali::Vector< int > *)jarg1;
51607   {
51608     try {
51609       (arg1)->Release();
51610     } catch (std::out_of_range& e) {
51611       {
51612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (std::exception& e) {
51615       {
51616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51617       };
51618     } catch (Dali::DaliException e) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51621       };
51622     } catch (...) {
51623       {
51624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51625       };
51626     }
51627   }
51628
51629 }
51630
51631
51632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51633   int jresult ;
51634   int result;
51635
51636   result = (int)Dali::Vector< float >::BaseType;
51637   jresult = (int)result;
51638   return jresult;
51639 }
51640
51641
51642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51643   void * jresult ;
51644   Dali::Vector< float > *result = 0 ;
51645
51646   {
51647     try {
51648       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51649     } catch (std::out_of_range& e) {
51650       {
51651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51652       };
51653     } catch (std::exception& e) {
51654       {
51655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51656       };
51657     } catch (Dali::DaliException e) {
51658       {
51659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51660       };
51661     } catch (...) {
51662       {
51663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51664       };
51665     }
51666   }
51667
51668   jresult = (void *)result;
51669   return jresult;
51670 }
51671
51672
51673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51674   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51675
51676   arg1 = (Dali::Vector< float > *)jarg1;
51677   {
51678     try {
51679       delete arg1;
51680     } catch (std::out_of_range& e) {
51681       {
51682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51683       };
51684     } catch (std::exception& e) {
51685       {
51686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51687       };
51688     } catch (Dali::DaliException e) {
51689       {
51690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51691       };
51692     } catch (...) {
51693       {
51694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51695       };
51696     }
51697   }
51698
51699 }
51700
51701
51702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51703   void * jresult ;
51704   Dali::Vector< float > *arg1 = 0 ;
51705   Dali::Vector< float > *result = 0 ;
51706
51707   arg1 = (Dali::Vector< float > *)jarg1;
51708   if (!arg1) {
51709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51710     return 0;
51711   }
51712   {
51713     try {
51714       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51722       };
51723     } catch (Dali::DaliException e) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51726       };
51727     } catch (...) {
51728       {
51729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51730       };
51731     }
51732   }
51733
51734   jresult = (void *)result;
51735   return jresult;
51736 }
51737
51738
51739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51740   void * jresult ;
51741   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51742   Dali::Vector< float > *arg2 = 0 ;
51743   Dali::Vector< float > *result = 0 ;
51744
51745   arg1 = (Dali::Vector< float > *)jarg1;
51746   arg2 = (Dali::Vector< float > *)jarg2;
51747   if (!arg2) {
51748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51749     return 0;
51750   }
51751   {
51752     try {
51753       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51754     } catch (std::out_of_range& e) {
51755       {
51756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51757       };
51758     } catch (std::exception& e) {
51759       {
51760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51761       };
51762     } catch (Dali::DaliException e) {
51763       {
51764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51765       };
51766     } catch (...) {
51767       {
51768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51769       };
51770     }
51771   }
51772
51773   jresult = (void *)result;
51774   return jresult;
51775 }
51776
51777
51778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51779   void * jresult ;
51780   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51781   Dali::Vector< float >::Iterator result;
51782
51783   arg1 = (Dali::Vector< float > *)jarg1;
51784   {
51785     try {
51786       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51794       };
51795     } catch (Dali::DaliException e) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51798       };
51799     } catch (...) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51802       };
51803     }
51804   }
51805
51806   jresult = (void *)result;
51807   return jresult;
51808 }
51809
51810
51811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51812   void * jresult ;
51813   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51814   Dali::Vector< float >::Iterator result;
51815
51816   arg1 = (Dali::Vector< float > *)jarg1;
51817   {
51818     try {
51819       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (Dali::DaliException e) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51831       };
51832     } catch (...) {
51833       {
51834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51835       };
51836     }
51837   }
51838
51839   jresult = (void *)result;
51840   return jresult;
51841 }
51842
51843
51844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51845   void * jresult ;
51846   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51847   Dali::Vector< float >::SizeType arg2 ;
51848   Dali::Vector< float >::ItemType *result = 0 ;
51849
51850   arg1 = (Dali::Vector< float > *)jarg1;
51851   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51852   {
51853     try {
51854       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51855     } catch (std::out_of_range& e) {
51856       {
51857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51858       };
51859     } catch (std::exception& e) {
51860       {
51861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51862       };
51863     } catch (Dali::DaliException e) {
51864       {
51865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51866       };
51867     } catch (...) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51870       };
51871     }
51872   }
51873
51874   jresult = (void *)result;
51875   return jresult;
51876 }
51877
51878
51879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51880   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51881   Dali::Vector< float >::ItemType *arg2 = 0 ;
51882   Dali::Vector< float >::ItemType temp2 ;
51883
51884   arg1 = (Dali::Vector< float > *)jarg1;
51885   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51886   arg2 = &temp2;
51887   {
51888     try {
51889       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51890     } catch (std::out_of_range& e) {
51891       {
51892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51893       };
51894     } catch (std::exception& e) {
51895       {
51896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51897       };
51898     } catch (Dali::DaliException e) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51901       };
51902     } catch (...) {
51903       {
51904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51905       };
51906     }
51907   }
51908
51909 }
51910
51911
51912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51913   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51914   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51915   Dali::Vector< float >::ItemType *arg3 = 0 ;
51916   Dali::Vector< float >::ItemType temp3 ;
51917
51918   arg1 = (Dali::Vector< float > *)jarg1;
51919   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51920   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51921   arg3 = &temp3;
51922   {
51923     try {
51924       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51925     } catch (std::out_of_range& e) {
51926       {
51927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51928       };
51929     } catch (std::exception& e) {
51930       {
51931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51932       };
51933     } catch (Dali::DaliException e) {
51934       {
51935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51936       };
51937     } catch (...) {
51938       {
51939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51940       };
51941     }
51942   }
51943
51944 }
51945
51946
51947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51948   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51949   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51950   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51951   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51952
51953   arg1 = (Dali::Vector< float > *)jarg1;
51954   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51955   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51956   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51957   {
51958     try {
51959       (arg1)->Insert(arg2,arg3,arg4);
51960     } catch (std::out_of_range& e) {
51961       {
51962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51963       };
51964     } catch (std::exception& e) {
51965       {
51966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51967       };
51968     } catch (Dali::DaliException e) {
51969       {
51970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51971       };
51972     } catch (...) {
51973       {
51974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51975       };
51976     }
51977   }
51978
51979 }
51980
51981
51982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
51983   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51984   Dali::Vector< float >::SizeType arg2 ;
51985
51986   arg1 = (Dali::Vector< float > *)jarg1;
51987   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51988   {
51989     try {
51990       (arg1)->Reserve(arg2);
51991     } catch (std::out_of_range& e) {
51992       {
51993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51994       };
51995     } catch (std::exception& e) {
51996       {
51997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51998       };
51999     } catch (Dali::DaliException e) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52002       };
52003     } catch (...) {
52004       {
52005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52006       };
52007     }
52008   }
52009
52010 }
52011
52012 //// ========================= end of part 2 =============================
52013
52014 //// ========================== start part 3 ===============================
52015
52016
52017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52018   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52019   Dali::Vector< float >::SizeType arg2 ;
52020
52021   arg1 = (Dali::Vector< float > *)jarg1;
52022   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52023   {
52024     try {
52025       (arg1)->Resize(arg2);
52026     } catch (std::out_of_range& e) {
52027       {
52028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52029       };
52030     } catch (std::exception& e) {
52031       {
52032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52033       };
52034     } catch (Dali::DaliException e) {
52035       {
52036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52037       };
52038     } catch (...) {
52039       {
52040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52041       };
52042     }
52043   }
52044
52045 }
52046
52047
52048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52049   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52050   Dali::Vector< float >::SizeType arg2 ;
52051   Dali::Vector< float >::ItemType *arg3 = 0 ;
52052   Dali::Vector< float >::ItemType temp3 ;
52053
52054   arg1 = (Dali::Vector< float > *)jarg1;
52055   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52056   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52057   arg3 = &temp3;
52058   {
52059     try {
52060       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52061     } catch (std::out_of_range& e) {
52062       {
52063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (std::exception& e) {
52066       {
52067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52068       };
52069     } catch (Dali::DaliException e) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52072       };
52073     } catch (...) {
52074       {
52075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52076       };
52077     }
52078   }
52079
52080 }
52081
52082
52083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52084   void * jresult ;
52085   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52086   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52087   Dali::Vector< float >::Iterator result;
52088
52089   arg1 = (Dali::Vector< float > *)jarg1;
52090   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52091   {
52092     try {
52093       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52094     } catch (std::out_of_range& e) {
52095       {
52096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52097       };
52098     } catch (std::exception& e) {
52099       {
52100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52101       };
52102     } catch (Dali::DaliException e) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52105       };
52106     } catch (...) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52109       };
52110     }
52111   }
52112
52113   jresult = (void *)result;
52114   return jresult;
52115 }
52116
52117
52118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52119   void * jresult ;
52120   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52121   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52122   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52123   Dali::Vector< float >::Iterator result;
52124
52125   arg1 = (Dali::Vector< float > *)jarg1;
52126   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52127   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52128   {
52129     try {
52130       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52131     } catch (std::out_of_range& e) {
52132       {
52133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52134       };
52135     } catch (std::exception& e) {
52136       {
52137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52138       };
52139     } catch (Dali::DaliException e) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52142       };
52143     } catch (...) {
52144       {
52145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52146       };
52147     }
52148   }
52149
52150   jresult = (void *)result;
52151   return jresult;
52152 }
52153
52154
52155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52156   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52157   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52158
52159   arg1 = (Dali::Vector< float > *)jarg1;
52160   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52161   {
52162     try {
52163       (arg1)->Remove(arg2);
52164     } catch (std::out_of_range& e) {
52165       {
52166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52167       };
52168     } catch (std::exception& e) {
52169       {
52170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52171       };
52172     } catch (Dali::DaliException e) {
52173       {
52174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52175       };
52176     } catch (...) {
52177       {
52178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52179       };
52180     }
52181   }
52182
52183 }
52184
52185
52186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52187   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52188   Dali::Vector< float > *arg2 = 0 ;
52189
52190   arg1 = (Dali::Vector< float > *)jarg1;
52191   arg2 = (Dali::Vector< float > *)jarg2;
52192   if (!arg2) {
52193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52194     return ;
52195   }
52196   {
52197     try {
52198       (arg1)->Swap(*arg2);
52199     } catch (std::out_of_range& e) {
52200       {
52201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52202       };
52203     } catch (std::exception& e) {
52204       {
52205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52206       };
52207     } catch (Dali::DaliException e) {
52208       {
52209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52210       };
52211     } catch (...) {
52212       {
52213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52214       };
52215     }
52216   }
52217
52218 }
52219
52220
52221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52223
52224   arg1 = (Dali::Vector< float > *)jarg1;
52225   {
52226     try {
52227       (arg1)->Clear();
52228     } catch (std::out_of_range& e) {
52229       {
52230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (std::exception& e) {
52233       {
52234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52235       };
52236     } catch (Dali::DaliException e) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52239       };
52240     } catch (...) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52243       };
52244     }
52245   }
52246
52247 }
52248
52249
52250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52251   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52252
52253   arg1 = (Dali::Vector< float > *)jarg1;
52254   {
52255     try {
52256       (arg1)->Release();
52257     } catch (std::out_of_range& e) {
52258       {
52259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (std::exception& e) {
52262       {
52263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52264       };
52265     } catch (Dali::DaliException e) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52268       };
52269     } catch (...) {
52270       {
52271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52272       };
52273     }
52274   }
52275
52276 }
52277
52278
52279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52280   int jresult ;
52281   int result;
52282
52283   result = (int)Dali::Vector< unsigned char >::BaseType;
52284   jresult = (int)result;
52285   return jresult;
52286 }
52287
52288
52289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52290   void * jresult ;
52291   Dali::Vector< unsigned char > *result = 0 ;
52292
52293   {
52294     try {
52295       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52296     } catch (std::out_of_range& e) {
52297       {
52298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (std::exception& e) {
52301       {
52302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52303       };
52304     } catch (Dali::DaliException e) {
52305       {
52306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52307       };
52308     } catch (...) {
52309       {
52310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52311       };
52312     }
52313   }
52314
52315   jresult = (void *)result;
52316   return jresult;
52317 }
52318
52319
52320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52321   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52322
52323   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52324   {
52325     try {
52326       delete arg1;
52327     } catch (std::out_of_range& e) {
52328       {
52329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52330       };
52331     } catch (std::exception& e) {
52332       {
52333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52334       };
52335     } catch (Dali::DaliException e) {
52336       {
52337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52338       };
52339     } catch (...) {
52340       {
52341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52342       };
52343     }
52344   }
52345
52346 }
52347
52348
52349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52350   void * jresult ;
52351   Dali::Vector< unsigned char > *arg1 = 0 ;
52352   Dali::Vector< unsigned char > *result = 0 ;
52353
52354   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52355   if (!arg1) {
52356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52357     return 0;
52358   }
52359   {
52360     try {
52361       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52362     } catch (std::out_of_range& e) {
52363       {
52364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52365       };
52366     } catch (std::exception& e) {
52367       {
52368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52369       };
52370     } catch (Dali::DaliException e) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52373       };
52374     } catch (...) {
52375       {
52376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52377       };
52378     }
52379   }
52380
52381   jresult = (void *)result;
52382   return jresult;
52383 }
52384
52385
52386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52387   void * jresult ;
52388   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52389   Dali::Vector< unsigned char > *arg2 = 0 ;
52390   Dali::Vector< unsigned char > *result = 0 ;
52391
52392   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52393   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52394   if (!arg2) {
52395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52396     return 0;
52397   }
52398   {
52399     try {
52400       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52401     } catch (std::out_of_range& e) {
52402       {
52403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52404       };
52405     } catch (std::exception& e) {
52406       {
52407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52408       };
52409     } catch (Dali::DaliException e) {
52410       {
52411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52412       };
52413     } catch (...) {
52414       {
52415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52416       };
52417     }
52418   }
52419
52420   jresult = (void *)result;
52421   return jresult;
52422 }
52423
52424
52425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52426   void * jresult ;
52427   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52428   Dali::Vector< unsigned char >::Iterator result;
52429
52430   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52431   {
52432     try {
52433       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52434     } catch (std::out_of_range& e) {
52435       {
52436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (std::exception& e) {
52439       {
52440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (Dali::DaliException e) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52445       };
52446     } catch (...) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52449       };
52450     }
52451   }
52452
52453   jresult = (void *)result;
52454   return jresult;
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52459   void * jresult ;
52460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52461   Dali::Vector< unsigned char >::Iterator result;
52462
52463   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52464   {
52465     try {
52466       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52467     } catch (std::out_of_range& e) {
52468       {
52469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (std::exception& e) {
52472       {
52473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (Dali::DaliException e) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485
52486   jresult = (void *)result;
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52492   void * jresult ;
52493   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52494   Dali::Vector< unsigned char >::SizeType arg2 ;
52495   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52496
52497   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52498   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52499   {
52500     try {
52501       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52502     } catch (std::out_of_range& e) {
52503       {
52504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52505       };
52506     } catch (std::exception& e) {
52507       {
52508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52509       };
52510     } catch (Dali::DaliException e) {
52511       {
52512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52513       };
52514     } catch (...) {
52515       {
52516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52517       };
52518     }
52519   }
52520
52521   jresult = (void *)result;
52522   return jresult;
52523 }
52524
52525
52526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52527   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52528   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52529   Dali::Vector< unsigned char >::ItemType temp2 ;
52530
52531   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52532   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52533   arg2 = &temp2;
52534   {
52535     try {
52536       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52537     } catch (std::out_of_range& e) {
52538       {
52539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52540       };
52541     } catch (std::exception& e) {
52542       {
52543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52544       };
52545     } catch (Dali::DaliException e) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52548       };
52549     } catch (...) {
52550       {
52551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52552       };
52553     }
52554   }
52555
52556 }
52557
52558
52559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52560   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52561   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52562   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52563   Dali::Vector< unsigned char >::ItemType temp3 ;
52564
52565   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52566   arg2 = jarg2;
52567   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52568   arg3 = &temp3;
52569   {
52570     try {
52571       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52572     } catch (std::out_of_range& e) {
52573       {
52574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52575       };
52576     } catch (std::exception& e) {
52577       {
52578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52579       };
52580     } catch (Dali::DaliException e) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52583       };
52584     } catch (...) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52587       };
52588     }
52589   }
52590
52591
52592
52593 }
52594
52595
52596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52597   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52598   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52599   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52600   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52601
52602   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52603   arg2 = jarg2;
52604   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52605   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52606   {
52607     try {
52608       (arg1)->Insert(arg2,arg3,arg4);
52609     } catch (std::out_of_range& e) {
52610       {
52611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52612       };
52613     } catch (std::exception& e) {
52614       {
52615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52616       };
52617     } catch (Dali::DaliException e) {
52618       {
52619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52620       };
52621     } catch (...) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52624       };
52625     }
52626   }
52627
52628
52629
52630 }
52631
52632
52633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52634   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52635   Dali::Vector< unsigned char >::SizeType arg2 ;
52636
52637   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52638   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52639   {
52640     try {
52641       (arg1)->Reserve(arg2);
52642     } catch (std::out_of_range& e) {
52643       {
52644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52645       };
52646     } catch (std::exception& e) {
52647       {
52648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52649       };
52650     } catch (Dali::DaliException e) {
52651       {
52652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52653       };
52654     } catch (...) {
52655       {
52656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52657       };
52658     }
52659   }
52660
52661 }
52662
52663
52664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52665   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52666   Dali::Vector< unsigned char >::SizeType arg2 ;
52667
52668   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52669   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52670   {
52671     try {
52672       (arg1)->Resize(arg2);
52673     } catch (std::out_of_range& e) {
52674       {
52675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52676       };
52677     } catch (std::exception& e) {
52678       {
52679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52680       };
52681     } catch (Dali::DaliException e) {
52682       {
52683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52684       };
52685     } catch (...) {
52686       {
52687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52688       };
52689     }
52690   }
52691
52692 }
52693
52694
52695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52696   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52697   Dali::Vector< unsigned char >::SizeType arg2 ;
52698   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52699   Dali::Vector< unsigned char >::ItemType temp3 ;
52700
52701   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52702   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52703   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52704   arg3 = &temp3;
52705   {
52706     try {
52707       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52708     } catch (std::out_of_range& e) {
52709       {
52710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52711       };
52712     } catch (std::exception& e) {
52713       {
52714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52715       };
52716     } catch (Dali::DaliException e) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52719       };
52720     } catch (...) {
52721       {
52722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52723       };
52724     }
52725   }
52726
52727 }
52728
52729
52730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52731   void * jresult ;
52732   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52733   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52734   Dali::Vector< unsigned char >::Iterator result;
52735
52736   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52737   arg2 = jarg2;
52738   {
52739     try {
52740       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52741     } catch (std::out_of_range& e) {
52742       {
52743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52744       };
52745     } catch (std::exception& e) {
52746       {
52747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52748       };
52749     } catch (Dali::DaliException e) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52752       };
52753     } catch (...) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52756       };
52757     }
52758   }
52759
52760   jresult = (void *)result;
52761
52762
52763   return jresult;
52764 }
52765
52766
52767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52768   void * jresult ;
52769   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52770   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52771   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52772   Dali::Vector< unsigned char >::Iterator result;
52773
52774   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52775   arg2 = jarg2;
52776   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52777   {
52778     try {
52779       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52780     } catch (std::out_of_range& e) {
52781       {
52782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52783       };
52784     } catch (std::exception& e) {
52785       {
52786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52787       };
52788     } catch (Dali::DaliException e) {
52789       {
52790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52791       };
52792     } catch (...) {
52793       {
52794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52795       };
52796     }
52797   }
52798
52799   jresult = (void *)result;
52800
52801
52802   return jresult;
52803 }
52804
52805
52806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52807   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52808   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52809
52810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52811   arg2 = jarg2;
52812   {
52813     try {
52814       (arg1)->Remove(arg2);
52815     } catch (std::out_of_range& e) {
52816       {
52817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52818       };
52819     } catch (std::exception& e) {
52820       {
52821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52822       };
52823     } catch (Dali::DaliException e) {
52824       {
52825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52826       };
52827     } catch (...) {
52828       {
52829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52830       };
52831     }
52832   }
52833
52834
52835
52836 }
52837
52838
52839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52840   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52841   Dali::Vector< unsigned char > *arg2 = 0 ;
52842
52843   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52844   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52845   if (!arg2) {
52846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52847     return ;
52848   }
52849   {
52850     try {
52851       (arg1)->Swap(*arg2);
52852     } catch (std::out_of_range& e) {
52853       {
52854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52855       };
52856     } catch (std::exception& e) {
52857       {
52858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52859       };
52860     } catch (Dali::DaliException e) {
52861       {
52862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52863       };
52864     } catch (...) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52867       };
52868     }
52869   }
52870
52871 }
52872
52873
52874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52875   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52876
52877   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52878   {
52879     try {
52880       (arg1)->Clear();
52881     } catch (std::out_of_range& e) {
52882       {
52883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52884       };
52885     } catch (std::exception& e) {
52886       {
52887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52888       };
52889     } catch (Dali::DaliException e) {
52890       {
52891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52892       };
52893     } catch (...) {
52894       {
52895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52896       };
52897     }
52898   }
52899
52900 }
52901
52902
52903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52904   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52905
52906   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52907   {
52908     try {
52909       (arg1)->Release();
52910     } catch (std::out_of_range& e) {
52911       {
52912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52913       };
52914     } catch (std::exception& e) {
52915       {
52916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (Dali::DaliException e) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52921       };
52922     } catch (...) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52925       };
52926     }
52927   }
52928
52929 }
52930
52931
52932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52933   int jresult ;
52934   int result;
52935
52936   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52937   jresult = (int)result;
52938   return jresult;
52939 }
52940
52941
52942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52943   void * jresult ;
52944   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52945
52946   {
52947     try {
52948       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52949     } catch (std::out_of_range& e) {
52950       {
52951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52952       };
52953     } catch (std::exception& e) {
52954       {
52955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52956       };
52957     } catch (Dali::DaliException e) {
52958       {
52959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52960       };
52961     } catch (...) {
52962       {
52963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52964       };
52965     }
52966   }
52967
52968   jresult = (void *)result;
52969   return jresult;
52970 }
52971
52972
52973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52974   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52975
52976   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52977   {
52978     try {
52979       delete arg1;
52980     } catch (std::out_of_range& e) {
52981       {
52982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52983       };
52984     } catch (std::exception& e) {
52985       {
52986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52987       };
52988     } catch (Dali::DaliException e) {
52989       {
52990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52991       };
52992     } catch (...) {
52993       {
52994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52995       };
52996     }
52997   }
52998
52999 }
53000
53001
53002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53003   void * jresult ;
53004   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53005   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53006
53007   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53008   if (!arg1) {
53009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53010     return 0;
53011   }
53012   {
53013     try {
53014       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53015     } catch (std::out_of_range& e) {
53016       {
53017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53018       };
53019     } catch (std::exception& e) {
53020       {
53021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53022       };
53023     } catch (Dali::DaliException e) {
53024       {
53025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53026       };
53027     } catch (...) {
53028       {
53029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53030       };
53031     }
53032   }
53033
53034   jresult = (void *)result;
53035   return jresult;
53036 }
53037
53038
53039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53040   void * jresult ;
53041   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53042   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53043   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53044
53045   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53046   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53047   if (!arg2) {
53048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53049     return 0;
53050   }
53051   {
53052     try {
53053       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53054     } catch (std::out_of_range& e) {
53055       {
53056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53057       };
53058     } catch (std::exception& e) {
53059       {
53060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53061       };
53062     } catch (Dali::DaliException e) {
53063       {
53064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53065       };
53066     } catch (...) {
53067       {
53068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53069       };
53070     }
53071   }
53072
53073   jresult = (void *)result;
53074   return jresult;
53075 }
53076
53077
53078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53079   void * jresult ;
53080   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53081   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53082
53083   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53084   {
53085     try {
53086       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53087     } catch (std::out_of_range& e) {
53088       {
53089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53090       };
53091     } catch (std::exception& e) {
53092       {
53093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53094       };
53095     } catch (Dali::DaliException e) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53098       };
53099     } catch (...) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53102       };
53103     }
53104   }
53105
53106   jresult = (void *)result;
53107   return jresult;
53108 }
53109
53110
53111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53112   void * jresult ;
53113   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53114   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53115
53116   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53117   {
53118     try {
53119       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53120     } catch (std::out_of_range& e) {
53121       {
53122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (std::exception& e) {
53125       {
53126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53127       };
53128     } catch (Dali::DaliException e) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53135       };
53136     }
53137   }
53138
53139   jresult = (void *)result;
53140   return jresult;
53141 }
53142
53143
53144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53145   void * jresult ;
53146   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53147   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53148   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53149
53150   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53151   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53152   {
53153     try {
53154       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53155     } catch (std::out_of_range& e) {
53156       {
53157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (std::exception& e) {
53160       {
53161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (Dali::DaliException e) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53166       };
53167     } catch (...) {
53168       {
53169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53170       };
53171     }
53172   }
53173
53174   jresult = (void *)result;
53175   return jresult;
53176 }
53177
53178
53179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53180   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53181   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53182
53183   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53184   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53185   if (!arg2) {
53186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53187     return ;
53188   }
53189   {
53190     try {
53191       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53192     } catch (std::out_of_range& e) {
53193       {
53194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53195       };
53196     } catch (std::exception& e) {
53197       {
53198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53199       };
53200     } catch (Dali::DaliException e) {
53201       {
53202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53203       };
53204     } catch (...) {
53205       {
53206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53207       };
53208     }
53209   }
53210
53211 }
53212
53213
53214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53215   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53216   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53217   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53218
53219   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53220   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53221   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53222   if (!arg3) {
53223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53224     return ;
53225   }
53226   {
53227     try {
53228       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53229     } catch (std::out_of_range& e) {
53230       {
53231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53232       };
53233     } catch (std::exception& e) {
53234       {
53235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53236       };
53237     } catch (Dali::DaliException e) {
53238       {
53239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53240       };
53241     } catch (...) {
53242       {
53243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53244       };
53245     }
53246   }
53247
53248 }
53249
53250
53251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53252   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53253   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53254   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53255   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53256
53257   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53258   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53259   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53260   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53261   {
53262     try {
53263       (arg1)->Insert(arg2,arg3,arg4);
53264     } catch (std::out_of_range& e) {
53265       {
53266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53267       };
53268     } catch (std::exception& e) {
53269       {
53270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53271       };
53272     } catch (Dali::DaliException e) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53275       };
53276     } catch (...) {
53277       {
53278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53279       };
53280     }
53281   }
53282
53283 }
53284
53285
53286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53287   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53288   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53289
53290   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53291   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53292   {
53293     try {
53294       (arg1)->Reserve(arg2);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53302       };
53303     } catch (Dali::DaliException e) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53306       };
53307     } catch (...) {
53308       {
53309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53310       };
53311     }
53312   }
53313
53314 }
53315
53316
53317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53318   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53319   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53320
53321   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53322   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53323   {
53324     try {
53325       (arg1)->Resize(arg2);
53326     } catch (std::out_of_range& e) {
53327       {
53328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53329       };
53330     } catch (std::exception& e) {
53331       {
53332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (Dali::DaliException e) {
53335       {
53336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53337       };
53338     } catch (...) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53341       };
53342     }
53343   }
53344
53345 }
53346
53347
53348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53349   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53350   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53351   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53352
53353   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53354   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53355   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53356   if (!arg3) {
53357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53358     return ;
53359   }
53360   {
53361     try {
53362       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53363     } catch (std::out_of_range& e) {
53364       {
53365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53366       };
53367     } catch (std::exception& e) {
53368       {
53369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53370       };
53371     } catch (Dali::DaliException e) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53374       };
53375     } catch (...) {
53376       {
53377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53378       };
53379     }
53380   }
53381
53382 }
53383
53384
53385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53386   void * jresult ;
53387   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53388   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53389   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53390
53391   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53392   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53393   {
53394     try {
53395       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53396     } catch (std::out_of_range& e) {
53397       {
53398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53399       };
53400     } catch (std::exception& e) {
53401       {
53402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53403       };
53404     } catch (Dali::DaliException e) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53407       };
53408     } catch (...) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53411       };
53412     }
53413   }
53414
53415   jresult = (void *)result;
53416   return jresult;
53417 }
53418
53419
53420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53421   void * jresult ;
53422   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53423   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53424   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53425   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53426
53427   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53428   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53429   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53430   {
53431     try {
53432       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53433     } catch (std::out_of_range& e) {
53434       {
53435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53436       };
53437     } catch (std::exception& e) {
53438       {
53439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53440       };
53441     } catch (Dali::DaliException e) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53444       };
53445     } catch (...) {
53446       {
53447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53448       };
53449     }
53450   }
53451
53452   jresult = (void *)result;
53453   return jresult;
53454 }
53455
53456
53457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53458   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53459   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53460
53461   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53462   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53463   {
53464     try {
53465       (arg1)->Remove(arg2);
53466     } catch (std::out_of_range& e) {
53467       {
53468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53469       };
53470     } catch (std::exception& e) {
53471       {
53472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53473       };
53474     } catch (Dali::DaliException e) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53477       };
53478     } catch (...) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53481       };
53482     }
53483   }
53484
53485 }
53486
53487
53488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53489   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53490   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53491
53492   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53493   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53494   if (!arg2) {
53495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53496     return ;
53497   }
53498   {
53499     try {
53500       (arg1)->Swap(*arg2);
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53516       };
53517     }
53518   }
53519
53520 }
53521
53522
53523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53524   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53525
53526   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53527   {
53528     try {
53529       (arg1)->Clear();
53530     } catch (std::out_of_range& e) {
53531       {
53532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53533       };
53534     } catch (std::exception& e) {
53535       {
53536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53537       };
53538     } catch (Dali::DaliException e) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53541       };
53542     } catch (...) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53545       };
53546     }
53547   }
53548
53549 }
53550
53551
53552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53553   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53554
53555   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53556   {
53557     try {
53558       (arg1)->Release();
53559     } catch (std::out_of_range& e) {
53560       {
53561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (std::exception& e) {
53564       {
53565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53566       };
53567     } catch (Dali::DaliException e) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53570       };
53571     } catch (...) {
53572       {
53573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53574       };
53575     }
53576   }
53577
53578 }
53579
53580
53581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53582   void * jresult ;
53583   Dali::Signal< void () > *result = 0 ;
53584
53585   {
53586     try {
53587       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (Dali::DaliException e) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53603       };
53604     }
53605   }
53606
53607   jresult = (void *)result;
53608   return jresult;
53609 }
53610
53611
53612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53613   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53614
53615   arg1 = (Dali::Signal< void () > *)jarg1;
53616   {
53617     try {
53618       delete arg1;
53619     } catch (std::out_of_range& e) {
53620       {
53621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53622       };
53623     } catch (std::exception& e) {
53624       {
53625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53626       };
53627     } catch (Dali::DaliException e) {
53628       {
53629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53630       };
53631     } catch (...) {
53632       {
53633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53634       };
53635     }
53636   }
53637
53638 }
53639
53640
53641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53642   unsigned int jresult ;
53643   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53644   bool result;
53645
53646   arg1 = (Dali::Signal< void () > *)jarg1;
53647   {
53648     try {
53649       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53650     } catch (std::out_of_range& e) {
53651       {
53652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53653       };
53654     } catch (std::exception& e) {
53655       {
53656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53657       };
53658     } catch (Dali::DaliException e) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53661       };
53662     } catch (...) {
53663       {
53664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53665       };
53666     }
53667   }
53668
53669   jresult = result;
53670   return jresult;
53671 }
53672
53673
53674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53675   unsigned long jresult ;
53676   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53677   std::size_t result;
53678
53679   arg1 = (Dali::Signal< void () > *)jarg1;
53680   {
53681     try {
53682       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53683     } catch (std::out_of_range& e) {
53684       {
53685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53686       };
53687     } catch (std::exception& e) {
53688       {
53689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53690       };
53691     } catch (Dali::DaliException e) {
53692       {
53693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53694       };
53695     } catch (...) {
53696       {
53697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53698       };
53699     }
53700   }
53701
53702   jresult = (unsigned long)result;
53703   return jresult;
53704 }
53705
53706
53707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53708   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53709   void (*arg2)() = (void (*)()) 0 ;
53710
53711   arg1 = (Dali::Signal< void () > *)jarg1;
53712   arg2 = (void (*)())jarg2;
53713   {
53714     try {
53715       (arg1)->Connect(arg2);
53716     } catch (std::out_of_range& e) {
53717       {
53718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53719       };
53720     } catch (std::exception& e) {
53721       {
53722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53723       };
53724     } catch (Dali::DaliException e) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53727       };
53728     } catch (...) {
53729       {
53730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53731       };
53732     }
53733   }
53734
53735 }
53736
53737
53738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53739   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53740   void (*arg2)() = (void (*)()) 0 ;
53741
53742   arg1 = (Dali::Signal< void () > *)jarg1;
53743   arg2 = (void (*)())jarg2;
53744   {
53745     try {
53746       (arg1)->Disconnect(arg2);
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53754       };
53755     } catch (Dali::DaliException e) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53762       };
53763     }
53764   }
53765
53766 }
53767
53768
53769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53770   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53771   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53772   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53773
53774   arg1 = (Dali::Signal< void () > *)jarg1;
53775   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53776   arg3 = (Dali::FunctorDelegate *)jarg3;
53777   {
53778     try {
53779       (arg1)->Connect(arg2,arg3);
53780     } catch (std::out_of_range& e) {
53781       {
53782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53783       };
53784     } catch (std::exception& e) {
53785       {
53786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53787       };
53788     } catch (Dali::DaliException e) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53795       };
53796     }
53797   }
53798
53799 }
53800
53801
53802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53803   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53804
53805   arg1 = (Dali::Signal< void () > *)jarg1;
53806   {
53807     try {
53808       (arg1)->Emit();
53809     } catch (std::out_of_range& e) {
53810       {
53811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (std::exception& e) {
53814       {
53815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (Dali::DaliException e) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53820       };
53821     } catch (...) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53824       };
53825     }
53826   }
53827
53828 }
53829
53830
53831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53832   unsigned int jresult ;
53833   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53834   bool result;
53835
53836   arg1 = (Dali::Signal< void (float) > *)jarg1;
53837   {
53838     try {
53839       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53840     } catch (std::out_of_range& e) {
53841       {
53842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53843       };
53844     } catch (std::exception& e) {
53845       {
53846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53847       };
53848     } catch (Dali::DaliException e) {
53849       {
53850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53851       };
53852     } catch (...) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53855       };
53856     }
53857   }
53858
53859   jresult = result;
53860   return jresult;
53861 }
53862
53863
53864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53865   unsigned long jresult ;
53866   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53867   std::size_t result;
53868
53869   arg1 = (Dali::Signal< void (float) > *)jarg1;
53870   {
53871     try {
53872       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53873     } catch (std::out_of_range& e) {
53874       {
53875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (std::exception& e) {
53878       {
53879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (Dali::DaliException e) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53888       };
53889     }
53890   }
53891
53892   jresult = (unsigned long)result;
53893   return jresult;
53894 }
53895
53896
53897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53898   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53899   void (*arg2)(float) = (void (*)(float)) 0 ;
53900
53901   arg1 = (Dali::Signal< void (float) > *)jarg1;
53902   arg2 = (void (*)(float))jarg2;
53903   {
53904     try {
53905       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53913       };
53914     } catch (Dali::DaliException e) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53917       };
53918     } catch (...) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53921       };
53922     }
53923   }
53924
53925 }
53926
53927
53928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53929   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53930   void (*arg2)(float) = (void (*)(float)) 0 ;
53931
53932   arg1 = (Dali::Signal< void (float) > *)jarg1;
53933   arg2 = (void (*)(float))jarg2;
53934   {
53935     try {
53936       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53937     } catch (std::out_of_range& e) {
53938       {
53939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53940       };
53941     } catch (std::exception& e) {
53942       {
53943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53944       };
53945     } catch (Dali::DaliException e) {
53946       {
53947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53952       };
53953     }
53954   }
53955
53956 }
53957
53958
53959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53960   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53961   float arg2 ;
53962
53963   arg1 = (Dali::Signal< void (float) > *)jarg1;
53964   arg2 = (float)jarg2;
53965   {
53966     try {
53967       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53968     } catch (std::out_of_range& e) {
53969       {
53970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53971       };
53972     } catch (std::exception& e) {
53973       {
53974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53975       };
53976     } catch (Dali::DaliException e) {
53977       {
53978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53979       };
53980     } catch (...) {
53981       {
53982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53983       };
53984     }
53985   }
53986
53987 }
53988
53989
53990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
53991   void * jresult ;
53992   Dali::Signal< void (float) > *result = 0 ;
53993
53994   {
53995     try {
53996       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
53997     } catch (std::out_of_range& e) {
53998       {
53999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54000       };
54001     } catch (std::exception& e) {
54002       {
54003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54004       };
54005     } catch (Dali::DaliException e) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54012       };
54013     }
54014   }
54015
54016   jresult = (void *)result;
54017   return jresult;
54018 }
54019
54020
54021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54022   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54023
54024   arg1 = (Dali::Signal< void (float) > *)jarg1;
54025   {
54026     try {
54027       delete arg1;
54028     } catch (std::out_of_range& e) {
54029       {
54030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54031       };
54032     } catch (std::exception& e) {
54033       {
54034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54035       };
54036     } catch (Dali::DaliException e) {
54037       {
54038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54039       };
54040     } catch (...) {
54041       {
54042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54043       };
54044     }
54045   }
54046
54047 }
54048
54049
54050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54051   unsigned int jresult ;
54052   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54053   bool result;
54054
54055   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54056   {
54057     try {
54058       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54059     } catch (std::out_of_range& e) {
54060       {
54061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54062       };
54063     } catch (std::exception& e) {
54064       {
54065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (Dali::DaliException e) {
54068       {
54069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54070       };
54071     } catch (...) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54074       };
54075     }
54076   }
54077
54078   jresult = result;
54079   return jresult;
54080 }
54081
54082
54083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54084   unsigned long jresult ;
54085   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54086   std::size_t result;
54087
54088   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54089   {
54090     try {
54091       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (Dali::DaliException e) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54103       };
54104     } catch (...) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54107       };
54108     }
54109   }
54110
54111   jresult = (unsigned long)result;
54112   return jresult;
54113 }
54114
54115
54116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54118   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54119
54120   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54121   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54122   {
54123     try {
54124       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54125     } catch (std::out_of_range& e) {
54126       {
54127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54128       };
54129     } catch (std::exception& e) {
54130       {
54131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54132       };
54133     } catch (Dali::DaliException e) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54140       };
54141     }
54142   }
54143
54144 }
54145
54146
54147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54148   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54149   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54150
54151   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54152   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54153   {
54154     try {
54155       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54156     } catch (std::out_of_range& e) {
54157       {
54158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54159       };
54160     } catch (std::exception& e) {
54161       {
54162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54163       };
54164     } catch (Dali::DaliException e) {
54165       {
54166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54167       };
54168     } catch (...) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54171       };
54172     }
54173   }
54174
54175 }
54176
54177
54178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54179   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54180   Dali::BaseHandle arg2 ;
54181   Dali::BaseHandle *argp2 ;
54182
54183   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54184   argp2 = (Dali::BaseHandle *)jarg2;
54185   if (!argp2) {
54186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54187     return ;
54188   }
54189   arg2 = *argp2;
54190   {
54191     try {
54192       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54200       };
54201     } catch (Dali::DaliException e) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54204       };
54205     } catch (...) {
54206       {
54207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54208       };
54209     }
54210   }
54211
54212 }
54213
54214
54215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54216   void * jresult ;
54217   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54218
54219   {
54220     try {
54221       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54222     } catch (std::out_of_range& e) {
54223       {
54224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54225       };
54226     } catch (std::exception& e) {
54227       {
54228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54229       };
54230     } catch (Dali::DaliException e) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54233       };
54234     } catch (...) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54237       };
54238     }
54239   }
54240
54241   jresult = (void *)result;
54242   return jresult;
54243 }
54244
54245
54246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54247   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54248
54249   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54250   {
54251     try {
54252       delete arg1;
54253     } catch (std::out_of_range& e) {
54254       {
54255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54256       };
54257     } catch (std::exception& e) {
54258       {
54259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54260       };
54261     } catch (Dali::DaliException e) {
54262       {
54263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54264       };
54265     } catch (...) {
54266       {
54267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54268       };
54269     }
54270   }
54271
54272 }
54273
54274
54275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54276   unsigned int jresult ;
54277   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54278   bool result;
54279
54280   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54281   {
54282     try {
54283       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54284     } catch (std::out_of_range& e) {
54285       {
54286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54287       };
54288     } catch (std::exception& e) {
54289       {
54290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54291       };
54292     } catch (Dali::DaliException e) {
54293       {
54294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54299       };
54300     }
54301   }
54302
54303   jresult = result;
54304   return jresult;
54305 }
54306
54307
54308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54309   unsigned long jresult ;
54310   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54311   std::size_t result;
54312
54313   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54314   {
54315     try {
54316       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54317     } catch (std::out_of_range& e) {
54318       {
54319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54320       };
54321     } catch (std::exception& e) {
54322       {
54323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54324       };
54325     } catch (Dali::DaliException e) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54332       };
54333     }
54334   }
54335
54336   jresult = (unsigned long)result;
54337   return jresult;
54338 }
54339
54340
54341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54342   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54343   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54344
54345   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54346   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54347   {
54348     try {
54349       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54357       };
54358     } catch (Dali::DaliException e) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54361       };
54362     } catch (...) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54365       };
54366     }
54367   }
54368
54369 }
54370
54371
54372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54373   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54374   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54375
54376   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54377   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54378   {
54379     try {
54380       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54381     } catch (std::out_of_range& e) {
54382       {
54383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54384       };
54385     } catch (std::exception& e) {
54386       {
54387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54388       };
54389     } catch (Dali::DaliException e) {
54390       {
54391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54392       };
54393     } catch (...) {
54394       {
54395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54396       };
54397     }
54398   }
54399
54400 }
54401
54402
54403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54405   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54406
54407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54408   arg2 = (Dali::RefObject *)jarg2;
54409   {
54410     try {
54411       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54412     } catch (std::out_of_range& e) {
54413       {
54414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54415       };
54416     } catch (std::exception& e) {
54417       {
54418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54419       };
54420     } catch (Dali::DaliException e) {
54421       {
54422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54423       };
54424     } catch (...) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54427       };
54428     }
54429   }
54430
54431 }
54432
54433
54434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54435   void * jresult ;
54436   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54437
54438   {
54439     try {
54440       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54441     } catch (std::out_of_range& e) {
54442       {
54443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54444       };
54445     } catch (std::exception& e) {
54446       {
54447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54448       };
54449     } catch (Dali::DaliException e) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54452       };
54453     } catch (...) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54456       };
54457     }
54458   }
54459
54460   jresult = (void *)result;
54461   return jresult;
54462 }
54463
54464
54465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54466   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54467
54468   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54469   {
54470     try {
54471       delete arg1;
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54479       };
54480     } catch (Dali::DaliException e) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54483       };
54484     } catch (...) {
54485       {
54486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54487       };
54488     }
54489   }
54490
54491 }
54492
54493
54494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54495   unsigned int jresult ;
54496   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54497   bool result;
54498
54499   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54500   {
54501     try {
54502       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54503     } catch (std::out_of_range& e) {
54504       {
54505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54506       };
54507     } catch (std::exception& e) {
54508       {
54509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54510       };
54511     } catch (Dali::DaliException e) {
54512       {
54513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54514       };
54515     } catch (...) {
54516       {
54517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54518       };
54519     }
54520   }
54521
54522   jresult = result;
54523   return jresult;
54524 }
54525
54526
54527 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54528   unsigned long jresult ;
54529   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54530   std::size_t result;
54531
54532   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54533   {
54534     try {
54535       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54536     } catch (std::out_of_range& e) {
54537       {
54538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54539       };
54540     } catch (std::exception& e) {
54541       {
54542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54543       };
54544     } catch (Dali::DaliException e) {
54545       {
54546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54547       };
54548     } catch (...) {
54549       {
54550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54551       };
54552     }
54553   }
54554
54555   jresult = (unsigned long)result;
54556   return jresult;
54557 }
54558
54559
54560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54561   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54562   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54563
54564   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54565   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54566   {
54567     try {
54568       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54569     } catch (std::out_of_range& e) {
54570       {
54571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54572       };
54573     } catch (std::exception& e) {
54574       {
54575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54576       };
54577     } catch (Dali::DaliException e) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54580       };
54581     } catch (...) {
54582       {
54583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54584       };
54585     }
54586   }
54587
54588 }
54589
54590
54591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54592   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54593   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54594
54595   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54596   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54597   {
54598     try {
54599       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54600     } catch (std::out_of_range& e) {
54601       {
54602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54603       };
54604     } catch (std::exception& e) {
54605       {
54606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54607       };
54608     } catch (Dali::DaliException e) {
54609       {
54610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54611       };
54612     } catch (...) {
54613       {
54614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54615       };
54616     }
54617   }
54618
54619 }
54620
54621
54622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54623   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54624   Dali::PropertyNotification *arg2 = 0 ;
54625
54626   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54627   arg2 = (Dali::PropertyNotification *)jarg2;
54628   if (!arg2) {
54629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54630     return ;
54631   }
54632   {
54633     try {
54634       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54635     } catch (std::out_of_range& e) {
54636       {
54637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54638       };
54639     } catch (std::exception& e) {
54640       {
54641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54642       };
54643     } catch (Dali::DaliException e) {
54644       {
54645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54646       };
54647     } catch (...) {
54648       {
54649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54650       };
54651     }
54652   }
54653
54654 }
54655
54656
54657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54658   void * jresult ;
54659   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54660
54661   {
54662     try {
54663       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54664     } catch (std::out_of_range& e) {
54665       {
54666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54667       };
54668     } catch (std::exception& e) {
54669       {
54670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54671       };
54672     } catch (Dali::DaliException e) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54675       };
54676     } catch (...) {
54677       {
54678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54679       };
54680     }
54681   }
54682
54683   jresult = (void *)result;
54684   return jresult;
54685 }
54686
54687
54688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54689   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54690
54691   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54692   {
54693     try {
54694       delete arg1;
54695     } catch (std::out_of_range& e) {
54696       {
54697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54698       };
54699     } catch (std::exception& e) {
54700       {
54701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54702       };
54703     } catch (Dali::DaliException e) {
54704       {
54705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54706       };
54707     } catch (...) {
54708       {
54709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54710       };
54711     }
54712   }
54713
54714 }
54715
54716
54717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54718   unsigned int jresult ;
54719   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54720   bool result;
54721
54722   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54723   {
54724     try {
54725       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54733       };
54734     } catch (Dali::DaliException e) {
54735       {
54736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54737       };
54738     } catch (...) {
54739       {
54740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54741       };
54742     }
54743   }
54744
54745   jresult = result;
54746   return jresult;
54747 }
54748
54749
54750 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54751   unsigned long jresult ;
54752   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54753   std::size_t result;
54754
54755   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54756   {
54757     try {
54758       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54759     } catch (std::out_of_range& e) {
54760       {
54761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (std::exception& e) {
54764       {
54765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54766       };
54767     } catch (Dali::DaliException e) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54770       };
54771     } catch (...) {
54772       {
54773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54774       };
54775     }
54776   }
54777
54778   jresult = (unsigned long)result;
54779   return jresult;
54780 }
54781
54782
54783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54784   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54785   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54786
54787   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54788   arg2 = (void (*)(Dali::Image))jarg2;
54789   {
54790     try {
54791       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54792     } catch (std::out_of_range& e) {
54793       {
54794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54795       };
54796     } catch (std::exception& e) {
54797       {
54798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54799       };
54800     } catch (Dali::DaliException e) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54803       };
54804     } catch (...) {
54805       {
54806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54807       };
54808     }
54809   }
54810
54811 }
54812
54813
54814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54815   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54816   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54817
54818   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54819   arg2 = (void (*)(Dali::Image))jarg2;
54820   {
54821     try {
54822       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54823     } catch (std::out_of_range& e) {
54824       {
54825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54826       };
54827     } catch (std::exception& e) {
54828       {
54829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54830       };
54831     } catch (Dali::DaliException e) {
54832       {
54833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54834       };
54835     } catch (...) {
54836       {
54837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54838       };
54839     }
54840   }
54841
54842 }
54843
54844
54845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54846   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54847   Dali::Image arg2 ;
54848   Dali::Image *argp2 ;
54849
54850   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54851   argp2 = (Dali::Image *)jarg2;
54852   if (!argp2) {
54853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54854     return ;
54855   }
54856   arg2 = *argp2;
54857   {
54858     try {
54859       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54860     } catch (std::out_of_range& e) {
54861       {
54862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54863       };
54864     } catch (std::exception& e) {
54865       {
54866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54867       };
54868     } catch (Dali::DaliException e) {
54869       {
54870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54871       };
54872     } catch (...) {
54873       {
54874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54875       };
54876     }
54877   }
54878
54879 }
54880
54881
54882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54883   void * jresult ;
54884   Dali::Signal< void (Dali::Image) > *result = 0 ;
54885
54886   {
54887     try {
54888       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54889     } catch (std::out_of_range& e) {
54890       {
54891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54892       };
54893     } catch (std::exception& e) {
54894       {
54895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54896       };
54897     } catch (Dali::DaliException e) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54904       };
54905     }
54906   }
54907
54908   jresult = (void *)result;
54909   return jresult;
54910 }
54911
54912
54913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54914   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54915
54916   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54917   {
54918     try {
54919       delete arg1;
54920     } catch (std::out_of_range& e) {
54921       {
54922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54923       };
54924     } catch (std::exception& e) {
54925       {
54926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54927       };
54928     } catch (Dali::DaliException e) {
54929       {
54930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54931       };
54932     } catch (...) {
54933       {
54934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54935       };
54936     }
54937   }
54938
54939 }
54940
54941
54942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54943   void * jresult ;
54944   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54945
54946   {
54947     try {
54948       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54949     } catch (std::out_of_range& e) {
54950       {
54951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54952       };
54953     } catch (std::exception& e) {
54954       {
54955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54956       };
54957     } catch (Dali::DaliException e) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54960       };
54961     } catch (...) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54964       };
54965     }
54966   }
54967
54968   jresult = (void *)result;
54969   return jresult;
54970 }
54971
54972
54973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54974   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54975
54976   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
54977   {
54978     try {
54979       delete arg1;
54980     } catch (std::out_of_range& e) {
54981       {
54982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54983       };
54984     } catch (std::exception& e) {
54985       {
54986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54987       };
54988     } catch (Dali::DaliException e) {
54989       {
54990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54991       };
54992     } catch (...) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54995       };
54996     }
54997   }
54998
54999 }
55000
55001
55002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55003   unsigned int jresult ;
55004   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55005   bool result;
55006
55007   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55008   {
55009     try {
55010       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);
55011     } catch (std::out_of_range& e) {
55012       {
55013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55014       };
55015     } catch (std::exception& e) {
55016       {
55017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55018       };
55019     } catch (Dali::DaliException e) {
55020       {
55021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55022       };
55023     } catch (...) {
55024       {
55025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55026       };
55027     }
55028   }
55029
55030   jresult = result;
55031   return jresult;
55032 }
55033
55034
55035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55036   unsigned long jresult ;
55037   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55038   std::size_t result;
55039
55040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55041   {
55042     try {
55043       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);
55044     } catch (std::out_of_range& e) {
55045       {
55046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (std::exception& e) {
55049       {
55050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55051       };
55052     } catch (Dali::DaliException e) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55055       };
55056     } catch (...) {
55057       {
55058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55059       };
55060     }
55061   }
55062
55063   jresult = (unsigned long)result;
55064   return jresult;
55065 }
55066
55067
55068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55069   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55070   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55071
55072   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55073   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55074   {
55075     try {
55076       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55084       };
55085     } catch (Dali::DaliException e) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55088       };
55089     } catch (...) {
55090       {
55091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55092       };
55093     }
55094   }
55095
55096 }
55097
55098
55099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55100   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55101   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55102
55103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55104   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55105   {
55106     try {
55107       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55108     } catch (std::out_of_range& e) {
55109       {
55110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55111       };
55112     } catch (std::exception& e) {
55113       {
55114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55115       };
55116     } catch (Dali::DaliException e) {
55117       {
55118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55119       };
55120     } catch (...) {
55121       {
55122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55123       };
55124     }
55125   }
55126
55127 }
55128
55129
55130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55131   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55132   Dali::Actor arg2 ;
55133   Dali::LongPressGesture *arg3 = 0 ;
55134   Dali::Actor *argp2 ;
55135
55136   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55137   argp2 = (Dali::Actor *)jarg2;
55138   if (!argp2) {
55139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55140     return ;
55141   }
55142   arg2 = *argp2;
55143   arg3 = (Dali::LongPressGesture *)jarg3;
55144   if (!arg3) {
55145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55146     return ;
55147   }
55148   {
55149     try {
55150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55151     } catch (std::out_of_range& e) {
55152       {
55153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55154       };
55155     } catch (std::exception& e) {
55156       {
55157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55158       };
55159     } catch (Dali::DaliException e) {
55160       {
55161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55162       };
55163     } catch (...) {
55164       {
55165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55166       };
55167     }
55168   }
55169
55170 }
55171
55172
55173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55174   void * jresult ;
55175   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55176
55177   {
55178     try {
55179       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55187       };
55188     } catch (Dali::DaliException e) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55191       };
55192     } catch (...) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55195       };
55196     }
55197   }
55198
55199   jresult = (void *)result;
55200   return jresult;
55201 }
55202
55203
55204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55205   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55206
55207   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55208   {
55209     try {
55210       delete arg1;
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55218       };
55219     } catch (Dali::DaliException e) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55222       };
55223     } catch (...) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55226       };
55227     }
55228   }
55229
55230 }
55231
55232
55233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55234   unsigned int jresult ;
55235   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55236   bool result;
55237
55238   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55239   {
55240     try {
55241       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);
55242     } catch (std::out_of_range& e) {
55243       {
55244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55245       };
55246     } catch (std::exception& e) {
55247       {
55248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55249       };
55250     } catch (Dali::DaliException e) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55253       };
55254     } catch (...) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55257       };
55258     }
55259   }
55260
55261   jresult = result;
55262   return jresult;
55263 }
55264
55265
55266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55267   unsigned long jresult ;
55268   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55269   std::size_t result;
55270
55271   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55272   {
55273     try {
55274       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);
55275     } catch (std::out_of_range& e) {
55276       {
55277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (std::exception& e) {
55280       {
55281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55282       };
55283     } catch (Dali::DaliException e) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55290       };
55291     }
55292   }
55293
55294   jresult = (unsigned long)result;
55295   return jresult;
55296 }
55297
55298
55299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55300   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55301   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55302
55303   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55304   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55305   {
55306     try {
55307       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55308     } catch (std::out_of_range& e) {
55309       {
55310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55311       };
55312     } catch (std::exception& e) {
55313       {
55314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55315       };
55316     } catch (Dali::DaliException e) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55319       };
55320     } catch (...) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55323       };
55324     }
55325   }
55326
55327 }
55328
55329
55330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55331   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55332   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55333
55334   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55335   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55336   {
55337     try {
55338       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55339     } catch (std::out_of_range& e) {
55340       {
55341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55342       };
55343     } catch (std::exception& e) {
55344       {
55345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55346       };
55347     } catch (Dali::DaliException e) {
55348       {
55349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55350       };
55351     } catch (...) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55354       };
55355     }
55356   }
55357
55358 }
55359
55360
55361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55362   unsigned int jresult ;
55363   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55364   Dali::Actor arg2 ;
55365   Dali::TouchData *arg3 = 0 ;
55366   Dali::Actor *argp2 ;
55367   bool result;
55368
55369   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55370   argp2 = (Dali::Actor *)jarg2;
55371   if (!argp2) {
55372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55373     return 0;
55374   }
55375   arg2 = *argp2;
55376   arg3 = (Dali::TouchData *)jarg3;
55377   if (!arg3) {
55378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55379     return 0;
55380   }
55381   {
55382     try {
55383       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55384     } catch (std::out_of_range& e) {
55385       {
55386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55387       };
55388     } catch (std::exception& e) {
55389       {
55390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (Dali::DaliException e) {
55393       {
55394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55395       };
55396     } catch (...) {
55397       {
55398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55399       };
55400     }
55401   }
55402
55403   jresult = result;
55404   return jresult;
55405 }
55406
55407
55408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55409   void * jresult ;
55410   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55411
55412   {
55413     try {
55414       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (Dali::DaliException e) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55430       };
55431     }
55432   }
55433
55434   jresult = (void *)result;
55435   return jresult;
55436 }
55437
55438
55439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55440   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55441
55442   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55443   {
55444     try {
55445       delete arg1;
55446     } catch (std::out_of_range& e) {
55447       {
55448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55449       };
55450     } catch (std::exception& e) {
55451       {
55452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55453       };
55454     } catch (Dali::DaliException e) {
55455       {
55456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55457       };
55458     } catch (...) {
55459       {
55460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55461       };
55462     }
55463   }
55464
55465 }
55466
55467
55468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55469   unsigned int jresult ;
55470   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55471   bool result;
55472
55473   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55474   {
55475     try {
55476       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);
55477     } catch (std::out_of_range& e) {
55478       {
55479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55480       };
55481     } catch (std::exception& e) {
55482       {
55483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55484       };
55485     } catch (Dali::DaliException e) {
55486       {
55487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55488       };
55489     } catch (...) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55492       };
55493     }
55494   }
55495
55496   jresult = result;
55497   return jresult;
55498 }
55499
55500
55501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55502   unsigned long jresult ;
55503   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55504   std::size_t result;
55505
55506   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55507   {
55508     try {
55509       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);
55510     } catch (std::out_of_range& e) {
55511       {
55512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (std::exception& e) {
55515       {
55516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55517       };
55518     } catch (Dali::DaliException e) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55521       };
55522     } catch (...) {
55523       {
55524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55525       };
55526     }
55527   }
55528
55529   jresult = (unsigned long)result;
55530   return jresult;
55531 }
55532
55533
55534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55535   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55536   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55537
55538   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55539   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55540   {
55541     try {
55542       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55543     } catch (std::out_of_range& e) {
55544       {
55545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55546       };
55547     } catch (std::exception& e) {
55548       {
55549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55550       };
55551     } catch (Dali::DaliException e) {
55552       {
55553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55554       };
55555     } catch (...) {
55556       {
55557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55558       };
55559     }
55560   }
55561
55562 }
55563
55564
55565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55566   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55567   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55568
55569   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55570   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55571   {
55572     try {
55573       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55574     } catch (std::out_of_range& e) {
55575       {
55576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55577       };
55578     } catch (std::exception& e) {
55579       {
55580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55581       };
55582     } catch (Dali::DaliException e) {
55583       {
55584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55585       };
55586     } catch (...) {
55587       {
55588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55589       };
55590     }
55591   }
55592
55593 }
55594
55595
55596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55597   unsigned int jresult ;
55598   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55599   Dali::Actor arg2 ;
55600   Dali::HoverEvent *arg3 = 0 ;
55601   Dali::Actor *argp2 ;
55602   bool result;
55603
55604   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55605   argp2 = (Dali::Actor *)jarg2;
55606   if (!argp2) {
55607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55608     return 0;
55609   }
55610   arg2 = *argp2;
55611   arg3 = (Dali::HoverEvent *)jarg3;
55612   if (!arg3) {
55613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55614     return 0;
55615   }
55616   {
55617     try {
55618       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55619     } catch (std::out_of_range& e) {
55620       {
55621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55622       };
55623     } catch (std::exception& e) {
55624       {
55625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55626       };
55627     } catch (Dali::DaliException e) {
55628       {
55629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55630       };
55631     } catch (...) {
55632       {
55633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55634       };
55635     }
55636   }
55637
55638   jresult = result;
55639   return jresult;
55640 }
55641
55642
55643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55644   void * jresult ;
55645   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55646
55647   {
55648     try {
55649       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55650     } catch (std::out_of_range& e) {
55651       {
55652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55653       };
55654     } catch (std::exception& e) {
55655       {
55656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55657       };
55658     } catch (Dali::DaliException e) {
55659       {
55660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55661       };
55662     } catch (...) {
55663       {
55664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55665       };
55666     }
55667   }
55668
55669   jresult = (void *)result;
55670   return jresult;
55671 }
55672
55673
55674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55675   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55676
55677   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55678   {
55679     try {
55680       delete arg1;
55681     } catch (std::out_of_range& e) {
55682       {
55683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55684       };
55685     } catch (std::exception& e) {
55686       {
55687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55688       };
55689     } catch (Dali::DaliException e) {
55690       {
55691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55696       };
55697     }
55698   }
55699
55700 }
55701
55702
55703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55704   unsigned int jresult ;
55705   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55706   bool result;
55707
55708   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55709   {
55710     try {
55711       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);
55712     } catch (std::out_of_range& e) {
55713       {
55714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55715       };
55716     } catch (std::exception& e) {
55717       {
55718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55719       };
55720     } catch (Dali::DaliException e) {
55721       {
55722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55723       };
55724     } catch (...) {
55725       {
55726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55727       };
55728     }
55729   }
55730
55731   jresult = result;
55732   return jresult;
55733 }
55734
55735
55736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55737   unsigned long jresult ;
55738   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55739   std::size_t result;
55740
55741   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55742   {
55743     try {
55744       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);
55745     } catch (std::out_of_range& e) {
55746       {
55747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (std::exception& e) {
55750       {
55751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55752       };
55753     } catch (Dali::DaliException e) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55756       };
55757     } catch (...) {
55758       {
55759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55760       };
55761     }
55762   }
55763
55764   jresult = (unsigned long)result;
55765   return jresult;
55766 }
55767
55768
55769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55770   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55771   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55772
55773   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55774   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55775   {
55776     try {
55777       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55778     } catch (std::out_of_range& e) {
55779       {
55780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55781       };
55782     } catch (std::exception& e) {
55783       {
55784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55785       };
55786     } catch (Dali::DaliException e) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55789       };
55790     } catch (...) {
55791       {
55792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55793       };
55794     }
55795   }
55796
55797 }
55798
55799
55800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55801   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55802   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55803
55804   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55805   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55806   {
55807     try {
55808       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55809     } catch (std::out_of_range& e) {
55810       {
55811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55812       };
55813     } catch (std::exception& e) {
55814       {
55815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55816       };
55817     } catch (Dali::DaliException e) {
55818       {
55819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55820       };
55821     } catch (...) {
55822       {
55823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55824       };
55825     }
55826   }
55827
55828 }
55829
55830
55831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55832   unsigned int jresult ;
55833   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55834   Dali::Actor arg2 ;
55835   Dali::WheelEvent *arg3 = 0 ;
55836   Dali::Actor *argp2 ;
55837   bool result;
55838
55839   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55840   argp2 = (Dali::Actor *)jarg2;
55841   if (!argp2) {
55842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55843     return 0;
55844   }
55845   arg2 = *argp2;
55846   arg3 = (Dali::WheelEvent *)jarg3;
55847   if (!arg3) {
55848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55849     return 0;
55850   }
55851   {
55852     try {
55853       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55854     } catch (std::out_of_range& e) {
55855       {
55856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55857       };
55858     } catch (std::exception& e) {
55859       {
55860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55861       };
55862     } catch (Dali::DaliException e) {
55863       {
55864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55865       };
55866     } catch (...) {
55867       {
55868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55869       };
55870     }
55871   }
55872
55873   jresult = result;
55874   return jresult;
55875 }
55876
55877
55878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55879   void * jresult ;
55880   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55881
55882   {
55883     try {
55884       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55885     } catch (std::out_of_range& e) {
55886       {
55887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55888       };
55889     } catch (std::exception& e) {
55890       {
55891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55892       };
55893     } catch (Dali::DaliException e) {
55894       {
55895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55896       };
55897     } catch (...) {
55898       {
55899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55900       };
55901     }
55902   }
55903
55904   jresult = (void *)result;
55905   return jresult;
55906 }
55907
55908
55909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55910   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55911
55912   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55913   {
55914     try {
55915       delete arg1;
55916     } catch (std::out_of_range& e) {
55917       {
55918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55919       };
55920     } catch (std::exception& e) {
55921       {
55922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55923       };
55924     } catch (Dali::DaliException e) {
55925       {
55926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55927       };
55928     } catch (...) {
55929       {
55930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55931       };
55932     }
55933   }
55934
55935 }
55936
55937
55938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55939   unsigned int jresult ;
55940   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55941   bool result;
55942
55943   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55944   {
55945     try {
55946       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55947     } catch (std::out_of_range& e) {
55948       {
55949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55950       };
55951     } catch (std::exception& e) {
55952       {
55953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55954       };
55955     } catch (Dali::DaliException e) {
55956       {
55957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55958       };
55959     } catch (...) {
55960       {
55961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55962       };
55963     }
55964   }
55965
55966   jresult = result;
55967   return jresult;
55968 }
55969
55970
55971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55972   unsigned long jresult ;
55973   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55974   std::size_t result;
55975
55976   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55977   {
55978     try {
55979       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
55980     } catch (std::out_of_range& e) {
55981       {
55982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (std::exception& e) {
55985       {
55986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55987       };
55988     } catch (Dali::DaliException e) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55991       };
55992     } catch (...) {
55993       {
55994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55995       };
55996     }
55997   }
55998
55999   jresult = (unsigned long)result;
56000   return jresult;
56001 }
56002
56003
56004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56005   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56006   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56007
56008   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56009   arg2 = (void (*)(Dali::Actor))jarg2;
56010   {
56011     try {
56012       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56013     } catch (std::out_of_range& e) {
56014       {
56015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56016       };
56017     } catch (std::exception& e) {
56018       {
56019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56020       };
56021     } catch (Dali::DaliException e) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56028       };
56029     }
56030   }
56031
56032 }
56033
56034
56035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56036   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56037   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56038
56039   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56040   arg2 = (void (*)(Dali::Actor))jarg2;
56041   {
56042     try {
56043       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56044     } catch (std::out_of_range& e) {
56045       {
56046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56047       };
56048     } catch (std::exception& e) {
56049       {
56050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56051       };
56052     } catch (Dali::DaliException e) {
56053       {
56054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56055       };
56056     } catch (...) {
56057       {
56058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56059       };
56060     }
56061   }
56062
56063 }
56064
56065
56066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56067   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56068   Dali::Actor arg2 ;
56069   Dali::Actor *argp2 ;
56070
56071   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56072   argp2 = (Dali::Actor *)jarg2;
56073   if (!argp2) {
56074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56075     return ;
56076   }
56077   arg2 = *argp2;
56078   {
56079     try {
56080       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56081     } catch (std::out_of_range& e) {
56082       {
56083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56084       };
56085     } catch (std::exception& e) {
56086       {
56087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56088       };
56089     } catch (Dali::DaliException e) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56092       };
56093     } catch (...) {
56094       {
56095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56096       };
56097     }
56098   }
56099
56100 }
56101
56102
56103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56104   void * jresult ;
56105   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56106
56107   {
56108     try {
56109       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56117       };
56118     } catch (Dali::DaliException e) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56121       };
56122     } catch (...) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56125       };
56126     }
56127   }
56128
56129   jresult = (void *)result;
56130   return jresult;
56131 }
56132
56133
56134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56135   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56136
56137   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56138   {
56139     try {
56140       delete arg1;
56141     } catch (std::out_of_range& e) {
56142       {
56143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56144       };
56145     } catch (std::exception& e) {
56146       {
56147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56148       };
56149     } catch (Dali::DaliException e) {
56150       {
56151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56152       };
56153     } catch (...) {
56154       {
56155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56156       };
56157     }
56158   }
56159
56160 }
56161
56162
56163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56164   unsigned int jresult ;
56165   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56166   bool result;
56167
56168   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56169   {
56170     try {
56171       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56172     } catch (std::out_of_range& e) {
56173       {
56174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56175       };
56176     } catch (std::exception& e) {
56177       {
56178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56179       };
56180     } catch (Dali::DaliException e) {
56181       {
56182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56183       };
56184     } catch (...) {
56185       {
56186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56187       };
56188     }
56189   }
56190
56191   jresult = result;
56192   return jresult;
56193 }
56194
56195
56196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56197   unsigned long jresult ;
56198   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56199   std::size_t result;
56200
56201   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56202   {
56203     try {
56204       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (Dali::DaliException e) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56216       };
56217     } catch (...) {
56218       {
56219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56220       };
56221     }
56222   }
56223
56224   jresult = (unsigned long)result;
56225   return jresult;
56226 }
56227
56228
56229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56230   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56231   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56232
56233   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56234   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56235   {
56236     try {
56237       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56253       };
56254     }
56255   }
56256
56257 }
56258
56259
56260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56261   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56262   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56263
56264   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56265   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56266   {
56267     try {
56268       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56269     } catch (std::out_of_range& e) {
56270       {
56271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56272       };
56273     } catch (std::exception& e) {
56274       {
56275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56276       };
56277     } catch (Dali::DaliException e) {
56278       {
56279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56280       };
56281     } catch (...) {
56282       {
56283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56284       };
56285     }
56286   }
56287
56288 }
56289
56290
56291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56292   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56293   Dali::KeyEvent *arg2 = 0 ;
56294
56295   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56296   arg2 = (Dali::KeyEvent *)jarg2;
56297   if (!arg2) {
56298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56299     return ;
56300   }
56301   {
56302     try {
56303       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56311       };
56312     } catch (Dali::DaliException e) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56315       };
56316     } catch (...) {
56317       {
56318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56319       };
56320     }
56321   }
56322
56323 }
56324
56325
56326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56327   void * jresult ;
56328   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56329
56330   {
56331     try {
56332       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56333     } catch (std::out_of_range& e) {
56334       {
56335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56336       };
56337     } catch (std::exception& e) {
56338       {
56339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56340       };
56341     } catch (Dali::DaliException e) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56344       };
56345     } catch (...) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56348       };
56349     }
56350   }
56351
56352   jresult = (void *)result;
56353   return jresult;
56354 }
56355
56356
56357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56358   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56359
56360   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56361   {
56362     try {
56363       delete arg1;
56364     } catch (std::out_of_range& e) {
56365       {
56366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56367       };
56368     } catch (std::exception& e) {
56369       {
56370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56371       };
56372     } catch (Dali::DaliException e) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56375       };
56376     } catch (...) {
56377       {
56378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56379       };
56380     }
56381   }
56382
56383 }
56384
56385
56386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56387   unsigned int jresult ;
56388   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56389   bool result;
56390
56391   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56392   {
56393     try {
56394       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413
56414   jresult = result;
56415   return jresult;
56416 }
56417
56418
56419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56420   unsigned long jresult ;
56421   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56422   std::size_t result;
56423
56424   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56425   {
56426     try {
56427       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56428     } catch (std::out_of_range& e) {
56429       {
56430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (std::exception& e) {
56433       {
56434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (Dali::DaliException e) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56439       };
56440     } catch (...) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56443       };
56444     }
56445   }
56446
56447   jresult = (unsigned long)result;
56448   return jresult;
56449 }
56450
56451
56452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56453   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56454   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56455
56456   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56457   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56458   {
56459     try {
56460       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56461     } catch (std::out_of_range& e) {
56462       {
56463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56464       };
56465     } catch (std::exception& e) {
56466       {
56467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56468       };
56469     } catch (Dali::DaliException e) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56476       };
56477     }
56478   }
56479
56480 }
56481
56482
56483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56484   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56485   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56486
56487   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56488   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56489   {
56490     try {
56491       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56507       };
56508     }
56509   }
56510
56511 }
56512
56513
56514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56515   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56516   Dali::TouchData *arg2 = 0 ;
56517
56518   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56519   arg2 = (Dali::TouchData *)jarg2;
56520   if (!arg2) {
56521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56522     return ;
56523   }
56524   {
56525     try {
56526       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56527     } catch (std::out_of_range& e) {
56528       {
56529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56530       };
56531     } catch (std::exception& e) {
56532       {
56533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56534       };
56535     } catch (Dali::DaliException e) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56538       };
56539     } catch (...) {
56540       {
56541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56542       };
56543     }
56544   }
56545
56546 }
56547
56548
56549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56550   void * jresult ;
56551   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56552
56553   {
56554     try {
56555       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56556     } catch (std::out_of_range& e) {
56557       {
56558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56559       };
56560     } catch (std::exception& e) {
56561       {
56562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56563       };
56564     } catch (Dali::DaliException e) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56567       };
56568     } catch (...) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56571       };
56572     }
56573   }
56574
56575   jresult = (void *)result;
56576   return jresult;
56577 }
56578
56579
56580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56581   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56582
56583   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56584   {
56585     try {
56586       delete arg1;
56587     } catch (std::out_of_range& e) {
56588       {
56589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56590       };
56591     } catch (std::exception& e) {
56592       {
56593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56594       };
56595     } catch (Dali::DaliException e) {
56596       {
56597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56598       };
56599     } catch (...) {
56600       {
56601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56602       };
56603     }
56604   }
56605
56606 }
56607
56608
56609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56610   unsigned int jresult ;
56611   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56612   bool result;
56613
56614   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56615   {
56616     try {
56617       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56618     } catch (std::out_of_range& e) {
56619       {
56620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56621       };
56622     } catch (std::exception& e) {
56623       {
56624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56625       };
56626     } catch (Dali::DaliException e) {
56627       {
56628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56629       };
56630     } catch (...) {
56631       {
56632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56633       };
56634     }
56635   }
56636
56637   jresult = result;
56638   return jresult;
56639 }
56640
56641
56642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56643   unsigned long jresult ;
56644   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56645   std::size_t result;
56646
56647   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56648   {
56649     try {
56650       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56651     } catch (std::out_of_range& e) {
56652       {
56653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (std::exception& e) {
56656       {
56657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56658       };
56659     } catch (Dali::DaliException e) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56662       };
56663     } catch (...) {
56664       {
56665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56666       };
56667     }
56668   }
56669
56670   jresult = (unsigned long)result;
56671   return jresult;
56672 }
56673
56674
56675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56676   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56677   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56678
56679   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56680   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56681   {
56682     try {
56683       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56684     } catch (std::out_of_range& e) {
56685       {
56686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56687       };
56688     } catch (std::exception& e) {
56689       {
56690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56691       };
56692     } catch (Dali::DaliException e) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56695       };
56696     } catch (...) {
56697       {
56698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56699       };
56700     }
56701   }
56702
56703 }
56704
56705
56706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56707   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56708   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56709
56710   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56711   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56712   {
56713     try {
56714       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56715     } catch (std::out_of_range& e) {
56716       {
56717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56718       };
56719     } catch (std::exception& e) {
56720       {
56721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56722       };
56723     } catch (Dali::DaliException e) {
56724       {
56725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56726       };
56727     } catch (...) {
56728       {
56729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56730       };
56731     }
56732   }
56733
56734 }
56735
56736
56737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56738   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56739   Dali::WheelEvent *arg2 = 0 ;
56740
56741   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56742   arg2 = (Dali::WheelEvent *)jarg2;
56743   if (!arg2) {
56744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56745     return ;
56746   }
56747   {
56748     try {
56749       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56757       };
56758     } catch (Dali::DaliException e) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56761       };
56762     } catch (...) {
56763       {
56764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56765       };
56766     }
56767   }
56768
56769 }
56770
56771
56772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56773   void * jresult ;
56774   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56775
56776   {
56777     try {
56778       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56779     } catch (std::out_of_range& e) {
56780       {
56781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56782       };
56783     } catch (std::exception& e) {
56784       {
56785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56786       };
56787     } catch (Dali::DaliException e) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56790       };
56791     } catch (...) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56794       };
56795     }
56796   }
56797
56798   jresult = (void *)result;
56799   return jresult;
56800 }
56801
56802
56803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56804   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56805
56806   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56807   {
56808     try {
56809       delete arg1;
56810     } catch (std::out_of_range& e) {
56811       {
56812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56813       };
56814     } catch (std::exception& e) {
56815       {
56816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56817       };
56818     } catch (Dali::DaliException e) {
56819       {
56820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56821       };
56822     } catch (...) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56825       };
56826     }
56827   }
56828
56829 }
56830
56831
56832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56833   void * jresult ;
56834   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56835
56836   {
56837     try {
56838       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56839     } catch (std::out_of_range& e) {
56840       {
56841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56842       };
56843     } catch (std::exception& e) {
56844       {
56845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56846       };
56847     } catch (Dali::DaliException e) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56850       };
56851     } catch (...) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56854       };
56855     }
56856   }
56857
56858   jresult = (void *)result;
56859   return jresult;
56860 }
56861
56862
56863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56864   void * jresult ;
56865   Dali::Radian arg1 ;
56866   Dali::Radian arg2 ;
56867   Dali::Radian *argp1 ;
56868   Dali::Radian *argp2 ;
56869   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56870
56871   argp1 = (Dali::Radian *)jarg1;
56872   if (!argp1) {
56873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56874     return 0;
56875   }
56876   arg1 = *argp1;
56877   argp2 = (Dali::Radian *)jarg2;
56878   if (!argp2) {
56879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56880     return 0;
56881   }
56882   arg2 = *argp2;
56883   {
56884     try {
56885       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56886     } catch (std::out_of_range& e) {
56887       {
56888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56889       };
56890     } catch (std::exception& e) {
56891       {
56892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56893       };
56894     } catch (Dali::DaliException e) {
56895       {
56896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56897       };
56898     } catch (...) {
56899       {
56900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56901       };
56902     }
56903   }
56904
56905   jresult = (void *)result;
56906   return jresult;
56907 }
56908
56909
56910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56911   void * jresult ;
56912   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56913   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56914
56915   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56916   if (!arg1) {
56917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56918     return 0;
56919   }
56920   {
56921     try {
56922       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56923     } catch (std::out_of_range& e) {
56924       {
56925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56926       };
56927     } catch (std::exception& e) {
56928       {
56929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (Dali::DaliException e) {
56932       {
56933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56934       };
56935     } catch (...) {
56936       {
56937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56938       };
56939     }
56940   }
56941
56942   jresult = (void *)result;
56943   return jresult;
56944 }
56945
56946
56947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56948   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56949   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56950
56951   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56952   arg2 = (Dali::Radian *)jarg2;
56953   if (arg1) (arg1)->first = *arg2;
56954 }
56955
56956
56957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56958   void * jresult ;
56959   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56960   Dali::Radian *result = 0 ;
56961
56962   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56963   result = (Dali::Radian *)& ((arg1)->first);
56964   jresult = (void *)result;
56965   return jresult;
56966 }
56967
56968
56969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56970   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56971   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56972
56973   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56974   arg2 = (Dali::Radian *)jarg2;
56975   if (arg1) (arg1)->second = *arg2;
56976 }
56977
56978
56979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
56980   void * jresult ;
56981   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56982   Dali::Radian *result = 0 ;
56983
56984   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56985   result = (Dali::Radian *)& ((arg1)->second);
56986   jresult = (void *)result;
56987   return jresult;
56988 }
56989
56990
56991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
56992   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56993
56994   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56995   {
56996     try {
56997       delete arg1;
56998     } catch (std::out_of_range& e) {
56999       {
57000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57001       };
57002     } catch (std::exception& e) {
57003       {
57004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57005       };
57006     } catch (Dali::DaliException e) {
57007       {
57008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57009       };
57010     } catch (...) {
57011       {
57012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57013       };
57014     }
57015   }
57016
57017 }
57018
57019
57020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57021   unsigned int jresult ;
57022   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57023   bool result;
57024
57025   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57026   {
57027     try {
57028       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);
57029     } catch (std::out_of_range& e) {
57030       {
57031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57032       };
57033     } catch (std::exception& e) {
57034       {
57035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57036       };
57037     } catch (Dali::DaliException e) {
57038       {
57039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57040       };
57041     } catch (...) {
57042       {
57043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57044       };
57045     }
57046   }
57047
57048   jresult = result;
57049   return jresult;
57050 }
57051
57052
57053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57054   unsigned long jresult ;
57055   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57056   std::size_t result;
57057
57058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57059   {
57060     try {
57061       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);
57062     } catch (std::out_of_range& e) {
57063       {
57064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (std::exception& e) {
57067       {
57068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57069       };
57070     } catch (Dali::DaliException e) {
57071       {
57072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57077       };
57078     }
57079   }
57080
57081   jresult = (unsigned long)result;
57082   return jresult;
57083 }
57084
57085
57086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57087   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57088   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57089
57090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57091   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57092   {
57093     try {
57094       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57095     } catch (std::out_of_range& e) {
57096       {
57097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57098       };
57099     } catch (std::exception& e) {
57100       {
57101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57102       };
57103     } catch (Dali::DaliException e) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57106       };
57107     } catch (...) {
57108       {
57109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57110       };
57111     }
57112   }
57113
57114 }
57115
57116
57117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57118   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57119   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57120
57121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57122   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57123   {
57124     try {
57125       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57126     } catch (std::out_of_range& e) {
57127       {
57128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57129       };
57130     } catch (std::exception& e) {
57131       {
57132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57133       };
57134     } catch (Dali::DaliException e) {
57135       {
57136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57137       };
57138     } catch (...) {
57139       {
57140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57141       };
57142     }
57143   }
57144
57145 }
57146
57147
57148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57149   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57150   Dali::Actor arg2 ;
57151   Dali::PanGesture *arg3 = 0 ;
57152   Dali::Actor *argp2 ;
57153
57154   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57155   argp2 = (Dali::Actor *)jarg2;
57156   if (!argp2) {
57157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57158     return ;
57159   }
57160   arg2 = *argp2;
57161   arg3 = (Dali::PanGesture *)jarg3;
57162   if (!arg3) {
57163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57164     return ;
57165   }
57166   {
57167     try {
57168       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57169     } catch (std::out_of_range& e) {
57170       {
57171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57172       };
57173     } catch (std::exception& e) {
57174       {
57175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57176       };
57177     } catch (Dali::DaliException e) {
57178       {
57179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57180       };
57181     } catch (...) {
57182       {
57183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57184       };
57185     }
57186   }
57187
57188 }
57189
57190
57191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57192   void * jresult ;
57193   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57194
57195   {
57196     try {
57197       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57198     } catch (std::out_of_range& e) {
57199       {
57200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57201       };
57202     } catch (std::exception& e) {
57203       {
57204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57205       };
57206     } catch (Dali::DaliException e) {
57207       {
57208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57209       };
57210     } catch (...) {
57211       {
57212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57213       };
57214     }
57215   }
57216
57217   jresult = (void *)result;
57218   return jresult;
57219 }
57220
57221
57222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57223   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57224
57225   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57226   {
57227     try {
57228       delete arg1;
57229     } catch (std::out_of_range& e) {
57230       {
57231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57232       };
57233     } catch (std::exception& e) {
57234       {
57235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57236       };
57237     } catch (Dali::DaliException e) {
57238       {
57239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57240       };
57241     } catch (...) {
57242       {
57243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57244       };
57245     }
57246   }
57247
57248 }
57249
57250
57251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57252   unsigned int jresult ;
57253   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57254   bool result;
57255
57256   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57257   {
57258     try {
57259       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);
57260     } catch (std::out_of_range& e) {
57261       {
57262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57263       };
57264     } catch (std::exception& e) {
57265       {
57266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (Dali::DaliException e) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57271       };
57272     } catch (...) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57275       };
57276     }
57277   }
57278
57279   jresult = result;
57280   return jresult;
57281 }
57282
57283
57284 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57285   unsigned long jresult ;
57286   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57287   std::size_t result;
57288
57289   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57290   {
57291     try {
57292       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);
57293     } catch (std::out_of_range& e) {
57294       {
57295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57296       };
57297     } catch (std::exception& e) {
57298       {
57299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57300       };
57301     } catch (Dali::DaliException e) {
57302       {
57303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57304       };
57305     } catch (...) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57308       };
57309     }
57310   }
57311
57312   jresult = (unsigned long)result;
57313   return jresult;
57314 }
57315
57316
57317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57318   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57319   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57320
57321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57322   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57323   {
57324     try {
57325       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57326     } catch (std::out_of_range& e) {
57327       {
57328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57329       };
57330     } catch (std::exception& e) {
57331       {
57332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57333       };
57334     } catch (Dali::DaliException e) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57337       };
57338     } catch (...) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57341       };
57342     }
57343   }
57344
57345 }
57346
57347
57348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57349   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57350   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57351
57352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57353   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57354   {
57355     try {
57356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57357     } catch (std::out_of_range& e) {
57358       {
57359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57360       };
57361     } catch (std::exception& e) {
57362       {
57363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57364       };
57365     } catch (Dali::DaliException e) {
57366       {
57367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57368       };
57369     } catch (...) {
57370       {
57371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57372       };
57373     }
57374   }
57375
57376 }
57377
57378
57379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57380   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57381   Dali::Actor arg2 ;
57382   Dali::PinchGesture *arg3 = 0 ;
57383   Dali::Actor *argp2 ;
57384
57385   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57386   argp2 = (Dali::Actor *)jarg2;
57387   if (!argp2) {
57388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57389     return ;
57390   }
57391   arg2 = *argp2;
57392   arg3 = (Dali::PinchGesture *)jarg3;
57393   if (!arg3) {
57394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57395     return ;
57396   }
57397   {
57398     try {
57399       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57400     } catch (std::out_of_range& e) {
57401       {
57402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57403       };
57404     } catch (std::exception& e) {
57405       {
57406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57407       };
57408     } catch (Dali::DaliException e) {
57409       {
57410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57411       };
57412     } catch (...) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57415       };
57416     }
57417   }
57418
57419 }
57420
57421
57422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57423   void * jresult ;
57424   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57425
57426   {
57427     try {
57428       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57436       };
57437     } catch (Dali::DaliException e) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57440       };
57441     } catch (...) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57444       };
57445     }
57446   }
57447
57448   jresult = (void *)result;
57449   return jresult;
57450 }
57451
57452
57453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57454   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57455
57456   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57457   {
57458     try {
57459       delete arg1;
57460     } catch (std::out_of_range& e) {
57461       {
57462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57463       };
57464     } catch (std::exception& e) {
57465       {
57466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57467       };
57468     } catch (Dali::DaliException e) {
57469       {
57470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57471       };
57472     } catch (...) {
57473       {
57474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57475       };
57476     }
57477   }
57478
57479 }
57480
57481
57482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57483   unsigned int jresult ;
57484   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57485   bool result;
57486
57487   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57488   {
57489     try {
57490       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);
57491     } catch (std::out_of_range& e) {
57492       {
57493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57494       };
57495     } catch (std::exception& e) {
57496       {
57497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57498       };
57499     } catch (Dali::DaliException e) {
57500       {
57501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57502       };
57503     } catch (...) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57506       };
57507     }
57508   }
57509
57510   jresult = result;
57511   return jresult;
57512 }
57513
57514
57515 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57516   unsigned long jresult ;
57517   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57518   std::size_t result;
57519
57520   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57521   {
57522     try {
57523       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);
57524     } catch (std::out_of_range& e) {
57525       {
57526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (std::exception& e) {
57529       {
57530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (Dali::DaliException e) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57535       };
57536     } catch (...) {
57537       {
57538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57539       };
57540     }
57541   }
57542
57543   jresult = (unsigned long)result;
57544   return jresult;
57545 }
57546
57547
57548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57549   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57550   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57551
57552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57553   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57554   {
57555     try {
57556       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57557     } catch (std::out_of_range& e) {
57558       {
57559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57560       };
57561     } catch (std::exception& e) {
57562       {
57563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57564       };
57565     } catch (Dali::DaliException e) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57568       };
57569     } catch (...) {
57570       {
57571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57572       };
57573     }
57574   }
57575
57576 }
57577
57578
57579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57580   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57581   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57582
57583   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57584   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57585   {
57586     try {
57587       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57588     } catch (std::out_of_range& e) {
57589       {
57590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57591       };
57592     } catch (std::exception& e) {
57593       {
57594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57595       };
57596     } catch (Dali::DaliException e) {
57597       {
57598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57599       };
57600     } catch (...) {
57601       {
57602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57603       };
57604     }
57605   }
57606
57607 }
57608
57609
57610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57611   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57612   Dali::Actor arg2 ;
57613   Dali::TapGesture *arg3 = 0 ;
57614   Dali::Actor *argp2 ;
57615
57616   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57617   argp2 = (Dali::Actor *)jarg2;
57618   if (!argp2) {
57619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57620     return ;
57621   }
57622   arg2 = *argp2;
57623   arg3 = (Dali::TapGesture *)jarg3;
57624   if (!arg3) {
57625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57626     return ;
57627   }
57628   {
57629     try {
57630       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57631     } catch (std::out_of_range& e) {
57632       {
57633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57634       };
57635     } catch (std::exception& e) {
57636       {
57637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57638       };
57639     } catch (Dali::DaliException e) {
57640       {
57641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57642       };
57643     } catch (...) {
57644       {
57645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57646       };
57647     }
57648   }
57649
57650 }
57651
57652
57653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57654   void * jresult ;
57655   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57656
57657   {
57658     try {
57659       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57667       };
57668     } catch (Dali::DaliException e) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57675       };
57676     }
57677   }
57678
57679   jresult = (void *)result;
57680   return jresult;
57681 }
57682
57683
57684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57685   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57686
57687   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57688   {
57689     try {
57690       delete arg1;
57691     } catch (std::out_of_range& e) {
57692       {
57693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57694       };
57695     } catch (std::exception& e) {
57696       {
57697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57698       };
57699     } catch (Dali::DaliException e) {
57700       {
57701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57702       };
57703     } catch (...) {
57704       {
57705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57706       };
57707     }
57708   }
57709
57710 }
57711
57712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57713   unsigned int jresult ;
57714   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57715   bool result;
57716
57717   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57718   {
57719     try {
57720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57721     } catch (std::out_of_range& e) {
57722       {
57723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57724       };
57725     } catch (std::exception& e) {
57726       {
57727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57728       };
57729     } catch (Dali::DaliException e) {
57730       {
57731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57732       };
57733     } catch (...) {
57734       {
57735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57736       };
57737     }
57738   }
57739
57740   jresult = result;
57741   return jresult;
57742 }
57743
57744
57745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57746   unsigned long jresult ;
57747   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57748   std::size_t result;
57749
57750   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57751   {
57752     try {
57753       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (Dali::DaliException e) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57765       };
57766     } catch (...) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57769       };
57770     }
57771   }
57772
57773   jresult = (unsigned long)result;
57774   return jresult;
57775 }
57776
57777
57778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57779   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57780   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57781
57782   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57783   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57784   {
57785     try {
57786       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57787     } catch (std::out_of_range& e) {
57788       {
57789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57790       };
57791     } catch (std::exception& e) {
57792       {
57793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57794       };
57795     } catch (Dali::DaliException e) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57798       };
57799     } catch (...) {
57800       {
57801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57802       };
57803     }
57804   }
57805
57806 }
57807
57808
57809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57810   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57811   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57812
57813   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57814   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57815   {
57816     try {
57817       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57818     } catch (std::out_of_range& e) {
57819       {
57820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57821       };
57822     } catch (std::exception& e) {
57823       {
57824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57825       };
57826     } catch (Dali::DaliException e) {
57827       {
57828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57829       };
57830     } catch (...) {
57831       {
57832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57833       };
57834     }
57835   }
57836
57837 }
57838
57839
57840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57841   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57842   Dali::ResourceImage arg2 ;
57843   Dali::ResourceImage *argp2 ;
57844
57845   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57846   argp2 = (Dali::ResourceImage *)jarg2;
57847   if (!argp2) {
57848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57849     return ;
57850   }
57851   arg2 = *argp2;
57852   {
57853     try {
57854       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57855     } catch (std::out_of_range& e) {
57856       {
57857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57858       };
57859     } catch (std::exception& e) {
57860       {
57861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57862       };
57863     } catch (Dali::DaliException e) {
57864       {
57865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57866       };
57867     } catch (...) {
57868       {
57869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57870       };
57871     }
57872   }
57873
57874 }
57875
57876
57877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57878   void * jresult ;
57879   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57880
57881   {
57882     try {
57883       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57899       };
57900     }
57901   }
57902
57903   jresult = (void *)result;
57904   return jresult;
57905 }
57906
57907
57908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57909   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57910
57911   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57912   {
57913     try {
57914       delete arg1;
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57922       };
57923     } catch (Dali::DaliException e) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57930       };
57931     }
57932   }
57933
57934 }
57935
57936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57937   unsigned int jresult ;
57938   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57939   bool result = false;
57940
57941   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57942   {
57943     try {
57944       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);
57945     } catch (std::out_of_range& e) {
57946       {
57947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57948       };
57949     } catch (std::exception& e) {
57950       {
57951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57952       };
57953     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57954   }
57955   jresult = result;
57956   return jresult;
57957 }
57958
57959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57960   unsigned long jresult ;
57961   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57962   std::size_t result = 0;
57963
57964   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57965   {
57966     try {
57967       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);
57968     } catch (std::out_of_range& e) {
57969       {
57970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57971       };
57972     } catch (std::exception& e) {
57973       {
57974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57975       };
57976     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57977   }
57978   jresult = (unsigned long)result;
57979   return jresult;
57980 }
57981
57982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
57983   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57984   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57985
57986   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57987   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57988   {
57989     try {
57990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
57991     } catch (std::out_of_range& e) {
57992       {
57993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57994       };
57995     } catch (std::exception& e) {
57996       {
57997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57998       };
57999     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58000   }
58001 }
58002
58003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58004   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58005   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58006
58007   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58008   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58009   {
58010     try {
58011       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58012     } catch (std::out_of_range& e) {
58013       {
58014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58015       };
58016     } catch (std::exception& e) {
58017       {
58018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58019       };
58020     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58021   }
58022 }
58023
58024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58025   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58026   Dali::Actor arg2 ;
58027   //bool arg3 ;
58028   Dali::LayoutDirection::Type arg4 ;
58029   Dali::Actor *argp2 ;
58030
58031   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58032   argp2 = (Dali::Actor *)jarg2;
58033   if (!argp2) {
58034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58035     return ;
58036   }
58037   arg2 = *argp2;
58038   //arg3 = jarg3 ? true : false;
58039   arg4 = (Dali::LayoutDirection::Type)jarg4;
58040   {
58041     try {
58042       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58050       };
58051     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58052   }
58053 }
58054
58055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58056   void * jresult ;
58057   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58058
58059   {
58060     try {
58061       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58062     } catch (std::out_of_range& e) {
58063       {
58064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58065       };
58066     } catch (std::exception& e) {
58067       {
58068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58071   }
58072   jresult = (void *)result;
58073   return jresult;
58074 }
58075
58076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58077   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58078
58079   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58080   {
58081     try {
58082       delete arg1;
58083     } catch (std::out_of_range& e) {
58084       {
58085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58086       };
58087     } catch (std::exception& e) {
58088       {
58089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58090       };
58091     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58092   }
58093 }
58094
58095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58096   unsigned int jresult ;
58097   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58098   bool result;
58099
58100   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58101   {
58102     try {
58103       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);
58104     } catch (std::out_of_range& e) {
58105       {
58106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58107       };
58108     } catch (std::exception& e) {
58109       {
58110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58111       };
58112     } catch (Dali::DaliException e) {
58113       {
58114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58115       };
58116     } catch (...) {
58117       {
58118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58119       };
58120     }
58121   }
58122
58123   jresult = result;
58124   return jresult;
58125 }
58126
58127
58128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58129   unsigned long jresult ;
58130   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58131   std::size_t result;
58132
58133   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58134   {
58135     try {
58136       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);
58137     } catch (std::out_of_range& e) {
58138       {
58139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (std::exception& e) {
58142       {
58143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58144       };
58145     } catch (Dali::DaliException e) {
58146       {
58147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58148       };
58149     } catch (...) {
58150       {
58151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58152       };
58153     }
58154   }
58155
58156   jresult = (unsigned long)result;
58157   return jresult;
58158 }
58159
58160
58161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58162   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58163   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58164
58165   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58166   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58167   {
58168     try {
58169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58177       };
58178     } catch (Dali::DaliException e) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58181       };
58182     } catch (...) {
58183       {
58184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58185       };
58186     }
58187   }
58188
58189 }
58190
58191
58192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58193   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58194   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58195
58196   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58197   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58198   {
58199     try {
58200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58201     } catch (std::out_of_range& e) {
58202       {
58203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58204       };
58205     } catch (std::exception& e) {
58206       {
58207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58208       };
58209     } catch (Dali::DaliException e) {
58210       {
58211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58212       };
58213     } catch (...) {
58214       {
58215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58216       };
58217     }
58218   }
58219
58220 }
58221
58222
58223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58224   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58225   Dali::Actor arg2 ;
58226   bool arg3 ;
58227   Dali::DevelActor::VisibilityChange::Type arg4 ;
58228   Dali::Actor *argp2 ;
58229
58230   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58231   argp2 = (Dali::Actor *)jarg2;
58232   if (!argp2) {
58233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58234     return ;
58235   }
58236   arg2 = *argp2;
58237   arg3 = jarg3 ? true : false;
58238   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58239   {
58240     try {
58241       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58242     } catch (std::out_of_range& e) {
58243       {
58244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58245       };
58246     } catch (std::exception& e) {
58247       {
58248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58249       };
58250     } catch (Dali::DaliException e) {
58251       {
58252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58253       };
58254     } catch (...) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58257       };
58258     }
58259   }
58260
58261 }
58262
58263
58264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58265   void * jresult ;
58266   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58267
58268   {
58269     try {
58270       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58278       };
58279     } catch (Dali::DaliException e) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58282       };
58283     } catch (...) {
58284       {
58285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58286       };
58287     }
58288   }
58289
58290   jresult = (void *)result;
58291   return jresult;
58292 }
58293
58294
58295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58296   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58297
58298   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58299   {
58300     try {
58301       delete arg1;
58302     } catch (std::out_of_range& e) {
58303       {
58304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58305       };
58306     } catch (std::exception& e) {
58307       {
58308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58309       };
58310     } catch (Dali::DaliException e) {
58311       {
58312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58313       };
58314     } catch (...) {
58315       {
58316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58317       };
58318     }
58319   }
58320
58321 }
58322
58323
58324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58325   void * jresult ;
58326   Dali::Timer *result = 0 ;
58327
58328   {
58329     try {
58330       result = (Dali::Timer *)new Dali::Timer();
58331     } catch (std::out_of_range& e) {
58332       {
58333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58334       };
58335     } catch (std::exception& e) {
58336       {
58337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58338       };
58339     } catch (Dali::DaliException e) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58346       };
58347     }
58348   }
58349
58350   jresult = (void *)result;
58351   return jresult;
58352 }
58353
58354
58355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58356   void * jresult ;
58357   unsigned int arg1 ;
58358   Dali::Timer result;
58359
58360   arg1 = (unsigned int)jarg1;
58361   {
58362     try {
58363       result = Dali::Timer::New(arg1);
58364     } catch (std::out_of_range& e) {
58365       {
58366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (std::exception& e) {
58369       {
58370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58371       };
58372     } catch (Dali::DaliException e) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58375       };
58376     } catch (...) {
58377       {
58378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58379       };
58380     }
58381   }
58382
58383   jresult = new Dali::Timer((const Dali::Timer &)result);
58384   return jresult;
58385 }
58386
58387
58388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58389   void * jresult ;
58390   Dali::Timer *arg1 = 0 ;
58391   Dali::Timer *result = 0 ;
58392
58393   arg1 = (Dali::Timer *)jarg1;
58394   if (!arg1) {
58395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58396     return 0;
58397   }
58398   {
58399     try {
58400       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58401     } catch (std::out_of_range& e) {
58402       {
58403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (std::exception& e) {
58406       {
58407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58408       };
58409     } catch (Dali::DaliException e) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58412       };
58413     } catch (...) {
58414       {
58415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58416       };
58417     }
58418   }
58419
58420   jresult = (void *)result;
58421   return jresult;
58422 }
58423
58424
58425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58426   void * jresult ;
58427   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58428   Dali::Timer *arg2 = 0 ;
58429   Dali::Timer *result = 0 ;
58430
58431   arg1 = (Dali::Timer *)jarg1;
58432   arg2 = (Dali::Timer *)jarg2;
58433   if (!arg2) {
58434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58435     return 0;
58436   }
58437   {
58438     try {
58439       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58440     } catch (std::out_of_range& e) {
58441       {
58442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (std::exception& e) {
58445       {
58446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58447       };
58448     } catch (Dali::DaliException e) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58451       };
58452     } catch (...) {
58453       {
58454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58455       };
58456     }
58457   }
58458
58459   jresult = (void *)result;
58460   return jresult;
58461 }
58462
58463
58464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58465   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58466
58467   arg1 = (Dali::Timer *)jarg1;
58468   {
58469     try {
58470       delete arg1;
58471     } catch (std::out_of_range& e) {
58472       {
58473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58474       };
58475     } catch (std::exception& e) {
58476       {
58477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58478       };
58479     } catch (Dali::DaliException e) {
58480       {
58481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58482       };
58483     } catch (...) {
58484       {
58485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58486       };
58487     }
58488   }
58489
58490 }
58491
58492
58493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58494   void * jresult ;
58495   Dali::BaseHandle arg1 ;
58496   Dali::BaseHandle *argp1 ;
58497   Dali::Timer result;
58498
58499   argp1 = (Dali::BaseHandle *)jarg1;
58500   if (!argp1) {
58501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58502     return 0;
58503   }
58504   arg1 = *argp1;
58505   {
58506     try {
58507       result = Dali::Timer::DownCast(arg1);
58508     } catch (std::out_of_range& e) {
58509       {
58510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58511       };
58512     } catch (std::exception& e) {
58513       {
58514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58515       };
58516     } catch (Dali::DaliException e) {
58517       {
58518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58519       };
58520     } catch (...) {
58521       {
58522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58523       };
58524     }
58525   }
58526
58527   jresult = new Dali::Timer((const Dali::Timer &)result);
58528   return jresult;
58529 }
58530
58531
58532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58533   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58534
58535   arg1 = (Dali::Timer *)jarg1;
58536   {
58537     try {
58538       (arg1)->Start();
58539     } catch (std::out_of_range& e) {
58540       {
58541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58542       };
58543     } catch (std::exception& e) {
58544       {
58545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58546       };
58547     } catch (Dali::DaliException e) {
58548       {
58549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58550       };
58551     } catch (...) {
58552       {
58553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58554       };
58555     }
58556   }
58557
58558 }
58559
58560
58561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58562   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58563
58564   arg1 = (Dali::Timer *)jarg1;
58565   {
58566     try {
58567       (arg1)->Stop();
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58575       };
58576     } catch (Dali::DaliException e) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58579       };
58580     } catch (...) {
58581       {
58582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58583       };
58584     }
58585   }
58586
58587 }
58588
58589
58590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58591   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58592   unsigned int arg2 ;
58593
58594   arg1 = (Dali::Timer *)jarg1;
58595   arg2 = (unsigned int)jarg2;
58596   {
58597     try {
58598       (arg1)->SetInterval(arg2);
58599     } catch (std::out_of_range& e) {
58600       {
58601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58602       };
58603     } catch (std::exception& e) {
58604       {
58605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58606       };
58607     } catch (Dali::DaliException e) {
58608       {
58609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58610       };
58611     } catch (...) {
58612       {
58613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58614       };
58615     }
58616   }
58617
58618 }
58619
58620
58621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58622   unsigned int jresult ;
58623   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58624   unsigned int result;
58625
58626   arg1 = (Dali::Timer *)jarg1;
58627   {
58628     try {
58629       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58630     } catch (std::out_of_range& e) {
58631       {
58632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58633       };
58634     } catch (std::exception& e) {
58635       {
58636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58637       };
58638     } catch (Dali::DaliException e) {
58639       {
58640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58641       };
58642     } catch (...) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58645       };
58646     }
58647   }
58648
58649   jresult = result;
58650   return jresult;
58651 }
58652
58653
58654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58655   unsigned int jresult ;
58656   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58657   bool result;
58658
58659   arg1 = (Dali::Timer *)jarg1;
58660   {
58661     try {
58662       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58663     } catch (std::out_of_range& e) {
58664       {
58665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (std::exception& e) {
58668       {
58669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58670       };
58671     } catch (Dali::DaliException e) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58674       };
58675     } catch (...) {
58676       {
58677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58678       };
58679     }
58680   }
58681
58682   jresult = result;
58683   return jresult;
58684 }
58685
58686
58687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58688   void * jresult ;
58689   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58690   Dali::Timer::TimerSignalType *result = 0 ;
58691
58692   arg1 = (Dali::Timer *)jarg1;
58693   {
58694     try {
58695       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58703       };
58704     } catch (Dali::DaliException e) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58707       };
58708     } catch (...) {
58709       {
58710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58711       };
58712     }
58713   }
58714
58715   jresult = (void *)result;
58716   return jresult;
58717 }
58718
58719
58720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58721   void * jresult ;
58722   Dali::DragAndDropDetector *result = 0 ;
58723
58724   {
58725     try {
58726       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58727     } catch (std::out_of_range& e) {
58728       {
58729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58730       };
58731     } catch (std::exception& e) {
58732       {
58733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58734       };
58735     } catch (Dali::DaliException e) {
58736       {
58737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58738       };
58739     } catch (...) {
58740       {
58741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58742       };
58743     }
58744   }
58745
58746   jresult = (void *)result;
58747   return jresult;
58748 }
58749
58750
58751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58752   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58753
58754   arg1 = (Dali::DragAndDropDetector *)jarg1;
58755   {
58756     try {
58757       delete arg1;
58758     } catch (std::out_of_range& e) {
58759       {
58760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58761       };
58762     } catch (std::exception& e) {
58763       {
58764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58765       };
58766     } catch (Dali::DaliException e) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58769       };
58770     } catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58773       };
58774     }
58775   }
58776
58777 }
58778
58779
58780 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58781   char * jresult ;
58782   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58783   std::string *result = 0 ;
58784
58785   arg1 = (Dali::DragAndDropDetector *)jarg1;
58786   {
58787     try {
58788       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58789     } catch (std::out_of_range& e) {
58790       {
58791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58792       };
58793     } catch (std::exception& e) {
58794       {
58795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58796       };
58797     } catch (Dali::DaliException e) {
58798       {
58799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58800       };
58801     } catch (...) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58804       };
58805     }
58806   }
58807
58808   jresult = SWIG_csharp_string_callback(result->c_str());
58809   return jresult;
58810 }
58811
58812
58813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58814   void * jresult ;
58815   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58816   Dali::Vector2 result;
58817
58818   arg1 = (Dali::DragAndDropDetector *)jarg1;
58819   {
58820     try {
58821       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58822     } catch (std::out_of_range& e) {
58823       {
58824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (std::exception& e) {
58827       {
58828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58829       };
58830     } catch (Dali::DaliException e) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58833       };
58834     } catch (...) {
58835       {
58836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58837       };
58838     }
58839   }
58840
58841   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58842   return jresult;
58843 }
58844
58845
58846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58847   void * jresult ;
58848   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58849   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58850
58851   arg1 = (Dali::DragAndDropDetector *)jarg1;
58852   {
58853     try {
58854       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58855     } catch (std::out_of_range& e) {
58856       {
58857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (std::exception& e) {
58860       {
58861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (Dali::DaliException e) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58866       };
58867     } catch (...) {
58868       {
58869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58870       };
58871     }
58872   }
58873
58874   jresult = (void *)result;
58875   return jresult;
58876 }
58877
58878
58879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58880   void * jresult ;
58881   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58882   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58883
58884   arg1 = (Dali::DragAndDropDetector *)jarg1;
58885   {
58886     try {
58887       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58888     } catch (std::out_of_range& e) {
58889       {
58890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (std::exception& e) {
58893       {
58894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58895       };
58896     } catch (Dali::DaliException e) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58899       };
58900     } catch (...) {
58901       {
58902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58903       };
58904     }
58905   }
58906
58907   jresult = (void *)result;
58908   return jresult;
58909 }
58910
58911
58912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58913   void * jresult ;
58914   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58915   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58916
58917   arg1 = (Dali::DragAndDropDetector *)jarg1;
58918   {
58919     try {
58920       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58921     } catch (std::out_of_range& e) {
58922       {
58923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (std::exception& e) {
58926       {
58927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (Dali::DaliException e) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58932       };
58933     } catch (...) {
58934       {
58935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58936       };
58937     }
58938   }
58939
58940   jresult = (void *)result;
58941   return jresult;
58942 }
58943
58944
58945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58946   void * jresult ;
58947   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58948   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58949
58950   arg1 = (Dali::DragAndDropDetector *)jarg1;
58951   {
58952     try {
58953       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58954     } catch (std::out_of_range& e) {
58955       {
58956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (std::exception& e) {
58959       {
58960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58961       };
58962     } catch (Dali::DaliException e) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58965       };
58966     } catch (...) {
58967       {
58968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58969       };
58970     }
58971   }
58972
58973   jresult = (void *)result;
58974   return jresult;
58975 }
58976
58977
58978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
58979   void * jresult ;
58980   Dali::ApplicationExtensions *result = 0 ;
58981
58982   {
58983     try {
58984       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
58985     } catch (std::out_of_range& e) {
58986       {
58987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58988       };
58989     } catch (std::exception& e) {
58990       {
58991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58992       };
58993     } catch (Dali::DaliException e) {
58994       {
58995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58996       };
58997     } catch (...) {
58998       {
58999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59000       };
59001     }
59002   }
59003
59004   jresult = (void *)result;
59005   return jresult;
59006 }
59007
59008
59009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59010   void * jresult ;
59011   Dali::Application *arg1 = (Dali::Application *) 0 ;
59012   Dali::ApplicationExtensions *result = 0 ;
59013
59014   arg1 = (Dali::Application *)jarg1;
59015   {
59016     try {
59017       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59018     } catch (std::out_of_range& e) {
59019       {
59020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (std::exception& e) {
59023       {
59024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59025       };
59026     } catch (Dali::DaliException e) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59029       };
59030     } catch (...) {
59031       {
59032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59033       };
59034     }
59035   }
59036
59037   jresult = (void *)result;
59038   return jresult;
59039 }
59040
59041
59042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59043   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59044
59045   arg1 = (Dali::ApplicationExtensions *)jarg1;
59046   {
59047     try {
59048       delete arg1;
59049     } catch (std::out_of_range& e) {
59050       {
59051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59052       };
59053     } catch (std::exception& e) {
59054       {
59055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59056       };
59057     } catch (Dali::DaliException e) {
59058       {
59059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59060       };
59061     } catch (...) {
59062       {
59063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59064       };
59065     }
59066   }
59067
59068 }
59069
59070
59071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59072   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59073
59074   arg1 = (Dali::ApplicationExtensions *)jarg1;
59075   {
59076     try {
59077       (arg1)->Init();
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (Dali::DaliException e) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096
59097 }
59098
59099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59100   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59101
59102   arg1 = (Dali::ApplicationExtensions *)jarg1;
59103   {
59104     try {
59105       (arg1)->Start();
59106     } catch (std::out_of_range& e) {
59107       {
59108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59109       };
59110     } catch (std::exception& e) {
59111       {
59112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59113       };
59114     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59115   }
59116 }
59117
59118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59119   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59120
59121   arg1 = (Dali::ApplicationExtensions *)jarg1;
59122   {
59123     try {
59124       (arg1)->Terminate();
59125     } catch (std::out_of_range& e) {
59126       {
59127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (std::exception& e) {
59130       {
59131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59132       };
59133     } catch (Dali::DaliException e) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59140       };
59141     }
59142   }
59143
59144 }
59145
59146
59147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59148   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59149
59150   arg1 = (Dali::ApplicationExtensions *)jarg1;
59151   {
59152     try {
59153       (arg1)->Pause();
59154     } catch (std::out_of_range& e) {
59155       {
59156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59157       };
59158     } catch (std::exception& e) {
59159       {
59160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59161       };
59162     } catch (Dali::DaliException e) {
59163       {
59164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59165       };
59166     } catch (...) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59169       };
59170     }
59171   }
59172
59173 }
59174
59175
59176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59177   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59178
59179   arg1 = (Dali::ApplicationExtensions *)jarg1;
59180   {
59181     try {
59182       (arg1)->Resume();
59183     } catch (std::out_of_range& e) {
59184       {
59185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59186       };
59187     } catch (std::exception& e) {
59188       {
59189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59190       };
59191     } catch (Dali::DaliException e) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59194       };
59195     } catch (...) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59198       };
59199     }
59200   }
59201
59202 }
59203
59204
59205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59206   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59207
59208   arg1 = (Dali::ApplicationExtensions *)jarg1;
59209   {
59210     try {
59211       (arg1)->LanguageChange();
59212     } catch (std::out_of_range& e) {
59213       {
59214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59215       };
59216     } catch (std::exception& e) {
59217       {
59218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59219       };
59220     } catch (Dali::DaliException e) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59223       };
59224     } catch (...) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59227       };
59228     }
59229   }
59230
59231 }
59232
59233
59234
59235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59236   unsigned int jresult ;
59237   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59238   bool result;
59239
59240   arg1 = (Dali::Signal< bool () > *)jarg1;
59241   {
59242     try {
59243       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59244     } catch (std::out_of_range& e) {
59245       {
59246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59247       };
59248     } catch (std::exception& e) {
59249       {
59250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59251       };
59252     } catch (Dali::DaliException e) {
59253       {
59254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59255       };
59256     } catch (...) {
59257       {
59258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59259       };
59260     }
59261   }
59262
59263   jresult = result;
59264   return jresult;
59265 }
59266
59267
59268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59269   unsigned long jresult ;
59270   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59271   std::size_t result;
59272
59273   arg1 = (Dali::Signal< bool () > *)jarg1;
59274   {
59275     try {
59276       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59277     } catch (std::out_of_range& e) {
59278       {
59279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59280       };
59281     } catch (std::exception& e) {
59282       {
59283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59284       };
59285     } catch (Dali::DaliException e) {
59286       {
59287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59288       };
59289     } catch (...) {
59290       {
59291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59292       };
59293     }
59294   }
59295
59296   jresult = (unsigned long)result;
59297   return jresult;
59298 }
59299
59300
59301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59302   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59303   bool (*arg2)() = (bool (*)()) 0 ;
59304
59305   arg1 = (Dali::Signal< bool () > *)jarg1;
59306   arg2 = (bool (*)())jarg2;
59307   {
59308     try {
59309       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59310     } catch (std::out_of_range& e) {
59311       {
59312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59313       };
59314     } catch (std::exception& e) {
59315       {
59316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59317       };
59318     } catch (Dali::DaliException e) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59321       };
59322     } catch (...) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59325       };
59326     }
59327   }
59328
59329 }
59330
59331
59332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59333   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59334   bool (*arg2)() = (bool (*)()) 0 ;
59335
59336   arg1 = (Dali::Signal< bool () > *)jarg1;
59337   arg2 = (bool (*)())jarg2;
59338   {
59339     try {
59340       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59341     } catch (std::out_of_range& e) {
59342       {
59343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59344       };
59345     } catch (std::exception& e) {
59346       {
59347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59348       };
59349     } catch (Dali::DaliException e) {
59350       {
59351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59352       };
59353     } catch (...) {
59354       {
59355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59356       };
59357     }
59358   }
59359
59360 }
59361
59362
59363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59364   unsigned int jresult ;
59365   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59366   bool result;
59367
59368   arg1 = (Dali::Signal< bool () > *)jarg1;
59369   {
59370     try {
59371       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59372     } catch (std::out_of_range& e) {
59373       {
59374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59375       };
59376     } catch (std::exception& e) {
59377       {
59378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59379       };
59380     } catch (Dali::DaliException e) {
59381       {
59382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59383       };
59384     } catch (...) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59387       };
59388     }
59389   }
59390
59391   jresult = result;
59392   return jresult;
59393 }
59394
59395
59396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59397   void * jresult ;
59398   Dali::Signal< bool () > *result = 0 ;
59399
59400   {
59401     try {
59402       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59403     } catch (std::out_of_range& e) {
59404       {
59405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59406       };
59407     } catch (std::exception& e) {
59408       {
59409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59410       };
59411     } catch (Dali::DaliException e) {
59412       {
59413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59414       };
59415     } catch (...) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59418       };
59419     }
59420   }
59421
59422   jresult = (void *)result;
59423   return jresult;
59424 }
59425
59426
59427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59428   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59429
59430   arg1 = (Dali::Signal< bool () > *)jarg1;
59431   {
59432     try {
59433       delete arg1;
59434     } catch (std::out_of_range& e) {
59435       {
59436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59437       };
59438     } catch (std::exception& e) {
59439       {
59440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59441       };
59442     } catch (Dali::DaliException e) {
59443       {
59444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59445       };
59446     } catch (...) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59449       };
59450     }
59451   }
59452
59453 }
59454
59455
59456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59457   int jresult ;
59458   int result;
59459
59460   {
59461     try {
59462       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59463     } catch (std::out_of_range& e) {
59464       {
59465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59466       };
59467     } catch (std::exception& e) {
59468       {
59469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59470       };
59471     } catch (Dali::DaliException e) {
59472       {
59473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59474       };
59475     } catch (...) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59478       };
59479     }
59480   }
59481
59482   jresult = (int)result;
59483   return jresult;
59484 }
59485
59486
59487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59488   int jresult ;
59489   int result;
59490
59491   {
59492     try {
59493       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59501       };
59502     } catch (Dali::DaliException e) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59505       };
59506     } catch (...) {
59507       {
59508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59509       };
59510     }
59511   }
59512
59513   jresult = (int)result;
59514   return jresult;
59515 }
59516
59517
59518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59519   int jresult ;
59520   int result;
59521
59522   {
59523     try {
59524       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59525     } catch (std::out_of_range& e) {
59526       {
59527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59528       };
59529     } catch (std::exception& e) {
59530       {
59531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (Dali::DaliException e) {
59534       {
59535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59536       };
59537     } catch (...) {
59538       {
59539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59540       };
59541     }
59542   }
59543
59544   jresult = (int)result;
59545   return jresult;
59546 }
59547
59548
59549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59550   int jresult ;
59551   int result;
59552
59553   {
59554     try {
59555       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59556     } catch (std::out_of_range& e) {
59557       {
59558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59559       };
59560     } catch (std::exception& e) {
59561       {
59562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (Dali::DaliException e) {
59565       {
59566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59567       };
59568     } catch (...) {
59569       {
59570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59571       };
59572     }
59573   }
59574
59575   jresult = (int)result;
59576   return jresult;
59577 }
59578
59579
59580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59581   int jresult ;
59582   int result;
59583
59584   {
59585     try {
59586       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59587     } catch (std::out_of_range& e) {
59588       {
59589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (std::exception& e) {
59592       {
59593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (Dali::DaliException e) {
59596       {
59597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59598       };
59599     } catch (...) {
59600       {
59601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59602       };
59603     }
59604   }
59605
59606   jresult = (int)result;
59607   return jresult;
59608 }
59609
59610
59611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59612   int jresult ;
59613   int result;
59614
59615   {
59616     try {
59617       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59618     } catch (std::out_of_range& e) {
59619       {
59620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59621       };
59622     } catch (std::exception& e) {
59623       {
59624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59625       };
59626     } catch (Dali::DaliException e) {
59627       {
59628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59629       };
59630     } catch (...) {
59631       {
59632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59633       };
59634     }
59635   }
59636
59637   jresult = (int)result;
59638   return jresult;
59639 }
59640
59641
59642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59643   int jresult ;
59644   int result;
59645
59646   {
59647     try {
59648       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59649     } catch (std::out_of_range& e) {
59650       {
59651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59652       };
59653     } catch (std::exception& e) {
59654       {
59655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59656       };
59657     } catch (Dali::DaliException e) {
59658       {
59659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59660       };
59661     } catch (...) {
59662       {
59663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59664       };
59665     }
59666   }
59667
59668   jresult = (int)result;
59669   return jresult;
59670 }
59671
59672
59673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59674   int jresult ;
59675   int result;
59676
59677   {
59678     try {
59679       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59680     } catch (std::out_of_range& e) {
59681       {
59682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59683       };
59684     } catch (std::exception& e) {
59685       {
59686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59687       };
59688     } catch (Dali::DaliException e) {
59689       {
59690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59691       };
59692     } catch (...) {
59693       {
59694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59695       };
59696     }
59697   }
59698
59699   jresult = (int)result;
59700   return jresult;
59701 }
59702
59703
59704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59705   int jresult ;
59706   int result;
59707
59708   {
59709     try {
59710       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59711     } catch (std::out_of_range& e) {
59712       {
59713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59714       };
59715     } catch (std::exception& e) {
59716       {
59717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59718       };
59719     } catch (Dali::DaliException e) {
59720       {
59721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59722       };
59723     } catch (...) {
59724       {
59725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59726       };
59727     }
59728   }
59729
59730   jresult = (int)result;
59731   return jresult;
59732 }
59733
59734
59735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59736   int jresult ;
59737   int result;
59738
59739   {
59740     try {
59741       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59742     } catch (std::out_of_range& e) {
59743       {
59744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59745       };
59746     } catch (std::exception& e) {
59747       {
59748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (Dali::DaliException e) {
59751       {
59752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59753       };
59754     } catch (...) {
59755       {
59756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59757       };
59758     }
59759   }
59760
59761   jresult = (int)result;
59762   return jresult;
59763 }
59764
59765
59766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59767   int jresult ;
59768   int result;
59769
59770   {
59771     try {
59772       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59773     } catch (std::out_of_range& e) {
59774       {
59775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (std::exception& e) {
59778       {
59779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (Dali::DaliException e) {
59782       {
59783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59784       };
59785     } catch (...) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59788       };
59789     }
59790   }
59791
59792   jresult = (int)result;
59793   return jresult;
59794 }
59795
59796
59797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59798   int jresult ;
59799   int result;
59800
59801   {
59802     try {
59803       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59804     } catch (std::out_of_range& e) {
59805       {
59806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59807       };
59808     } catch (std::exception& e) {
59809       {
59810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59811       };
59812     } catch (Dali::DaliException e) {
59813       {
59814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59815       };
59816     } catch (...) {
59817       {
59818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59819       };
59820     }
59821   }
59822
59823   jresult = (int)result;
59824   return jresult;
59825 }
59826
59827
59828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59829   int jresult ;
59830   int result;
59831
59832   {
59833     try {
59834       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59835     } catch (std::out_of_range& e) {
59836       {
59837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59838       };
59839     } catch (std::exception& e) {
59840       {
59841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59842       };
59843     } catch (Dali::DaliException e) {
59844       {
59845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59846       };
59847     } catch (...) {
59848       {
59849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59850       };
59851     }
59852   }
59853
59854   jresult = (int)result;
59855   return jresult;
59856 }
59857
59858
59859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59860   int jresult ;
59861   int result;
59862
59863   {
59864     try {
59865       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59866     } catch (std::out_of_range& e) {
59867       {
59868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59869       };
59870     } catch (std::exception& e) {
59871       {
59872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59873       };
59874     } catch (Dali::DaliException e) {
59875       {
59876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59877       };
59878     } catch (...) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59881       };
59882     }
59883   }
59884
59885   jresult = (int)result;
59886   return jresult;
59887 }
59888
59889
59890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59891   int jresult ;
59892   int result;
59893
59894   {
59895     try {
59896       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59897     } catch (std::out_of_range& e) {
59898       {
59899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59900       };
59901     } catch (std::exception& e) {
59902       {
59903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59904       };
59905     } catch (Dali::DaliException e) {
59906       {
59907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59908       };
59909     } catch (...) {
59910       {
59911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59912       };
59913     }
59914   }
59915
59916   jresult = (int)result;
59917   return jresult;
59918 }
59919
59920
59921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59922   int jresult ;
59923   int result;
59924
59925   {
59926     try {
59927       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59928     } catch (std::out_of_range& e) {
59929       {
59930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59931       };
59932     } catch (std::exception& e) {
59933       {
59934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59935       };
59936     } catch (Dali::DaliException e) {
59937       {
59938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59939       };
59940     } catch (...) {
59941       {
59942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59943       };
59944     }
59945   }
59946
59947   jresult = (int)result;
59948   return jresult;
59949 }
59950
59951
59952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59953   int jresult ;
59954   int result;
59955
59956   {
59957     try {
59958       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (Dali::DaliException e) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59970       };
59971     } catch (...) {
59972       {
59973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59974       };
59975     }
59976   }
59977
59978   jresult = (int)result;
59979   return jresult;
59980 }
59981
59982
59983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59984   int jresult ;
59985   int result;
59986
59987   {
59988     try {
59989       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59990     } catch (std::out_of_range& e) {
59991       {
59992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59993       };
59994     } catch (std::exception& e) {
59995       {
59996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59997       };
59998     } catch (Dali::DaliException e) {
59999       {
60000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60001       };
60002     } catch (...) {
60003       {
60004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60005       };
60006     }
60007   }
60008
60009   jresult = (int)result;
60010   return jresult;
60011 }
60012
60013
60014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60015   int jresult ;
60016   int result;
60017
60018   {
60019     try {
60020       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60021     } catch (std::out_of_range& e) {
60022       {
60023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60024       };
60025     } catch (std::exception& e) {
60026       {
60027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60028       };
60029     } catch (Dali::DaliException e) {
60030       {
60031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60032       };
60033     } catch (...) {
60034       {
60035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60036       };
60037     }
60038   }
60039
60040   jresult = (int)result;
60041   return jresult;
60042 }
60043
60044
60045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60046   int jresult ;
60047   int result;
60048
60049   {
60050     try {
60051       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60052     } catch (std::out_of_range& e) {
60053       {
60054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60055       };
60056     } catch (std::exception& e) {
60057       {
60058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60059       };
60060     } catch (Dali::DaliException e) {
60061       {
60062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60063       };
60064     } catch (...) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60067       };
60068     }
60069   }
60070
60071   jresult = (int)result;
60072   return jresult;
60073 }
60074
60075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60076   int jresult ;
60077   int result;
60078
60079   {
60080     try {
60081       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60082     } catch (std::out_of_range& e) {
60083       {
60084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60085       };
60086     } catch (std::exception& e) {
60087       {
60088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60089       };
60090     } catch (Dali::DaliException e) {
60091       {
60092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60093       };
60094     } catch (...) {
60095       {
60096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60097       };
60098     }
60099   }
60100
60101   jresult = (int)result;
60102   return jresult;
60103 }
60104
60105
60106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60107   int jresult ;
60108   int result;
60109   {
60110     try
60111     {
60112       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60113     } catch (std::out_of_range& e) {
60114       {
60115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60116       };
60117     } catch (std::exception& e) {
60118       {
60119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60120       };
60121     } catch (Dali::DaliException e) {
60122       {
60123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60124       };
60125     } catch (...) {
60126       {
60127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60128       };
60129     }
60130   }
60131
60132   jresult = (int)result;
60133   return jresult;
60134 }
60135
60136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60137   int jresult ;
60138   int result;
60139   {
60140     try
60141     {
60142       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60143     } catch (std::out_of_range& e) {
60144       {
60145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (std::exception& e) {
60148       {
60149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60150       };
60151     } catch (Dali::DaliException e) {
60152       {
60153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60154       };
60155     } catch (...) {
60156       {
60157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60158       };
60159     }
60160   }
60161
60162   jresult = (int)result;
60163   return jresult;
60164 }
60165
60166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60167   int jresult ;
60168   int result;
60169   {
60170     try
60171     {
60172       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60173     } catch (std::out_of_range& e) {
60174       {
60175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60176       };
60177     } catch (std::exception& e) {
60178       {
60179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60180       };
60181     } catch (Dali::DaliException e) {
60182       {
60183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60184       };
60185     } catch (...) {
60186       {
60187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60188       };
60189     }
60190   }
60191
60192   jresult = (int)result;
60193   return jresult;
60194 }
60195
60196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60197   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60198 }
60199
60200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60201   int jresult ;
60202   int result;
60203   {
60204     try
60205     {
60206       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60207     } catch (std::out_of_range& e) {
60208       {
60209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (std::exception& e) {
60212       {
60213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (Dali::DaliException e) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60218       };
60219     } catch (...) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60222       };
60223     }
60224   }
60225
60226   jresult = (int)result;
60227   return jresult;
60228 }
60229
60230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60231   int jresult ;
60232   int result;
60233   {
60234     try
60235     {
60236       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60237     } catch (std::out_of_range& e) {
60238       {
60239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60240       };
60241     } catch (std::exception& e) {
60242       {
60243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60244       };
60245     } catch (Dali::DaliException e) {
60246       {
60247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60248       };
60249     } catch (...) {
60250       {
60251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60252       };
60253     }
60254   }
60255
60256   jresult = (int)result;
60257   return jresult;
60258 }
60259
60260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60261   int jresult ;
60262   int result;
60263
60264   {
60265     try {
60266       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60267     } catch (std::out_of_range& e) {
60268       {
60269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60270       };
60271     } catch (std::exception& e) {
60272       {
60273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60274       };
60275     } catch (Dali::DaliException e) {
60276       {
60277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60278       };
60279     } catch (...) {
60280       {
60281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60282       };
60283     }
60284   }
60285
60286   jresult = (int)result;
60287   return jresult;
60288 }
60289
60290
60291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60292   int jresult ;
60293   int result;
60294
60295   {
60296     try {
60297       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60298     } catch (std::out_of_range& e) {
60299       {
60300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60301       };
60302     } catch (std::exception& e) {
60303       {
60304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60305       };
60306     } catch (Dali::DaliException e) {
60307       {
60308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60309       };
60310     } catch (...) {
60311       {
60312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60313       };
60314     }
60315   }
60316
60317   jresult = (int)result;
60318   return jresult;
60319 }
60320
60321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60322   int jresult ;
60323   int result;
60324   {
60325     try
60326     {
60327       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60328     } catch (std::out_of_range& e) {
60329       {
60330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (std::exception& e) {
60333       {
60334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60335       };
60336     } catch (...) {
60337       {
60338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60339       };
60340     }
60341   }
60342   jresult = (int)result;
60343   return jresult;
60344 }
60345
60346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60347   int jresult ;
60348   int result;
60349   {
60350     try
60351     {
60352       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60353     } catch (std::out_of_range& e) {
60354       {
60355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60356       };
60357     } catch (std::exception& e) {
60358       {
60359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60360       };
60361     } catch (...) {
60362       {
60363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60364       };
60365     }
60366   }
60367   jresult = (int)result;
60368   return jresult;
60369 }
60370
60371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60372   int jresult ;
60373   int result;
60374   {
60375     try
60376     {
60377       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60378     } catch (std::out_of_range& e) {
60379       {
60380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (std::exception& e) {
60383       {
60384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (...) {
60387       {
60388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60389       };
60390     }
60391   }
60392   jresult = (int)result;
60393   return jresult;
60394 }
60395
60396
60397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60398   int jresult ;
60399   int result;
60400   {
60401     try
60402     {
60403       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60404     } catch (std::out_of_range& e) {
60405       {
60406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60407       };
60408     } catch (std::exception& e) {
60409       {
60410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60411       };
60412     } catch (...) {
60413       {
60414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60415       };
60416     }
60417   }
60418   jresult = (int)result;
60419   return jresult;
60420 }
60421
60422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60423   int jresult ;
60424   int result;
60425   {
60426     try
60427     {
60428       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60429     } catch (std::out_of_range& e) {
60430       {
60431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60432       };
60433     } catch (std::exception& e) {
60434       {
60435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60436       };
60437     } catch (...) {
60438       {
60439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60440       };
60441     }
60442   }
60443   jresult = (int)result;
60444   return jresult;
60445 }
60446
60447
60448
60449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60450   int jresult ;
60451   int result;
60452
60453   {
60454     try {
60455       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60456     } catch (std::out_of_range& e) {
60457       {
60458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (std::exception& e) {
60461       {
60462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60463       };
60464     } catch (Dali::DaliException e) {
60465       {
60466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60467       };
60468     } catch (...) {
60469       {
60470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60471       };
60472     }
60473   }
60474
60475   jresult = (int)result;
60476   return jresult;
60477 }
60478
60479
60480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60481   int jresult ;
60482   int result;
60483
60484   {
60485     try {
60486       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60487     } catch (std::out_of_range& e) {
60488       {
60489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (std::exception& e) {
60492       {
60493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60494       };
60495     } catch (Dali::DaliException e) {
60496       {
60497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60498       };
60499     } catch (...) {
60500       {
60501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60502       };
60503     }
60504   }
60505
60506   jresult = (int)result;
60507   return jresult;
60508 }
60509
60510
60511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60512   int jresult ;
60513   int result;
60514
60515   {
60516     try {
60517       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60518     } catch (std::out_of_range& e) {
60519       {
60520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60521       };
60522     } catch (std::exception& e) {
60523       {
60524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60525       };
60526     } catch (Dali::DaliException e) {
60527       {
60528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60529       };
60530     } catch (...) {
60531       {
60532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60533       };
60534     }
60535   }
60536
60537   jresult = (int)result;
60538   return jresult;
60539 }
60540
60541
60542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60543   int jresult ;
60544   int result;
60545
60546   {
60547     try {
60548       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60549     } catch (std::out_of_range& e) {
60550       {
60551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (std::exception& e) {
60554       {
60555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60556       };
60557     } catch (Dali::DaliException e) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60560       };
60561     } catch (...) {
60562       {
60563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60564       };
60565     }
60566   }
60567
60568   jresult = (int)result;
60569   return jresult;
60570 }
60571
60572
60573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60574   int jresult ;
60575   int result;
60576
60577   {
60578     try {
60579       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60580     } catch (std::out_of_range& e) {
60581       {
60582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (std::exception& e) {
60585       {
60586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (Dali::DaliException e) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60591       };
60592     } catch (...) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60595       };
60596     }
60597   }
60598
60599   jresult = (int)result;
60600   return jresult;
60601 }
60602
60603
60604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60605   int jresult ;
60606   int result;
60607
60608   {
60609     try {
60610       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60611     } catch (std::out_of_range& e) {
60612       {
60613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (std::exception& e) {
60616       {
60617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (Dali::DaliException e) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60622       };
60623     } catch (...) {
60624       {
60625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60626       };
60627     }
60628   }
60629
60630   jresult = (int)result;
60631   return jresult;
60632 }
60633
60634
60635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60636   int jresult ;
60637   int result;
60638
60639   {
60640     try {
60641       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60642     } catch (std::out_of_range& e) {
60643       {
60644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (std::exception& e) {
60647       {
60648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60649       };
60650     } catch (Dali::DaliException e) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60653       };
60654     } catch (...) {
60655       {
60656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60657       };
60658     }
60659   }
60660
60661   jresult = (int)result;
60662   return jresult;
60663 }
60664
60665 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60666   int jresult ;
60667   int result;
60668
60669   {
60670     try {
60671       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60672     } catch (std::out_of_range& e) {
60673       {
60674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60675       };
60676     } catch (std::exception& e) {
60677       {
60678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60679       };
60680     } catch (...) {
60681       {
60682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60683       };
60684     }
60685   }
60686   jresult = (int)result;
60687   return jresult;
60688 }
60689
60690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60691   int jresult ;
60692   int result;
60693
60694   {
60695     try {
60696       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60697     } catch (std::out_of_range& e) {
60698       {
60699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60700       };
60701     } catch (std::exception& e) {
60702       {
60703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (Dali::DaliException e) {
60706       {
60707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60712       };
60713     }
60714   }
60715
60716   jresult = (int)result;
60717   return jresult;
60718 }
60719
60720
60721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60722   int jresult ;
60723   int result;
60724
60725   {
60726     try {
60727       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60728     } catch (std::out_of_range& e) {
60729       {
60730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (std::exception& e) {
60733       {
60734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60735       };
60736     } catch (Dali::DaliException e) {
60737       {
60738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60739       };
60740     } catch (...) {
60741       {
60742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60743       };
60744     }
60745   }
60746
60747   jresult = (int)result;
60748   return jresult;
60749 }
60750
60751
60752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60753   int jresult ;
60754   int result;
60755
60756   {
60757     try {
60758       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60759     } catch (std::out_of_range& e) {
60760       {
60761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60762       };
60763     } catch (std::exception& e) {
60764       {
60765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60766       };
60767     } catch (Dali::DaliException e) {
60768       {
60769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60770       };
60771     } catch (...) {
60772       {
60773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60774       };
60775     }
60776   }
60777
60778   jresult = (int)result;
60779   return jresult;
60780 }
60781
60782
60783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60784   int jresult ;
60785   int result;
60786
60787   {
60788     try {
60789       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60790     } catch (std::out_of_range& e) {
60791       {
60792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60793       };
60794     } catch (std::exception& e) {
60795       {
60796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60797       };
60798     } catch (Dali::DaliException e) {
60799       {
60800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60801       };
60802     } catch (...) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60805       };
60806     }
60807   }
60808
60809   jresult = (int)result;
60810   return jresult;
60811 }
60812
60813
60814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60815   int jresult ;
60816   int result;
60817
60818   {
60819     try {
60820       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60821     } catch (std::out_of_range& e) {
60822       {
60823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (std::exception& e) {
60826       {
60827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60828       };
60829     } catch (Dali::DaliException e) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60832       };
60833     } catch (...) {
60834       {
60835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60836       };
60837     }
60838   }
60839
60840   jresult = (int)result;
60841   return jresult;
60842 }
60843
60844
60845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60846   int jresult ;
60847   int result;
60848
60849   {
60850     try {
60851       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60852     } catch (std::out_of_range& e) {
60853       {
60854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60855       };
60856     } catch (std::exception& e) {
60857       {
60858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60859       };
60860     } catch (Dali::DaliException e) {
60861       {
60862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60867       };
60868     }
60869   }
60870
60871   jresult = (int)result;
60872   return jresult;
60873 }
60874
60875
60876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60877   int jresult ;
60878   int result;
60879
60880   {
60881     try {
60882       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60883     } catch (std::out_of_range& e) {
60884       {
60885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60886       };
60887     } catch (std::exception& e) {
60888       {
60889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60890       };
60891     } catch (Dali::DaliException e) {
60892       {
60893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60894       };
60895     } catch (...) {
60896       {
60897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60898       };
60899     }
60900   }
60901
60902   jresult = (int)result;
60903   return jresult;
60904 }
60905
60906
60907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60908   int jresult ;
60909   int result;
60910
60911   {
60912     try {
60913       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60914     } catch (std::out_of_range& e) {
60915       {
60916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60917       };
60918     } catch (std::exception& e) {
60919       {
60920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60921       };
60922     } catch (Dali::DaliException e) {
60923       {
60924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60925       };
60926     } catch (...) {
60927       {
60928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60929       };
60930     }
60931   }
60932
60933   jresult = (int)result;
60934   return jresult;
60935 }
60936
60937
60938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60939   int jresult ;
60940   int result;
60941
60942   {
60943     try {
60944       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60945     } catch (std::out_of_range& e) {
60946       {
60947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60948       };
60949     } catch (std::exception& e) {
60950       {
60951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60952       };
60953     } catch (Dali::DaliException e) {
60954       {
60955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60956       };
60957     } catch (...) {
60958       {
60959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60960       };
60961     }
60962   }
60963
60964   jresult = (int)result;
60965   return jresult;
60966 }
60967
60968
60969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60970   int jresult ;
60971   int result;
60972
60973   {
60974     try {
60975       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60976     } catch (std::out_of_range& e) {
60977       {
60978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60979       };
60980     } catch (std::exception& e) {
60981       {
60982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60983       };
60984     } catch (Dali::DaliException e) {
60985       {
60986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60987       };
60988     } catch (...) {
60989       {
60990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60991       };
60992     }
60993   }
60994
60995   jresult = (int)result;
60996   return jresult;
60997 }
60998
60999
61000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61001   int jresult ;
61002   int result;
61003
61004   {
61005     try {
61006       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61007     } catch (std::out_of_range& e) {
61008       {
61009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61010       };
61011     } catch (std::exception& e) {
61012       {
61013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (Dali::DaliException e) {
61016       {
61017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61018       };
61019     } catch (...) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61022       };
61023     }
61024   }
61025
61026   jresult = (int)result;
61027   return jresult;
61028 }
61029
61030
61031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61032   int jresult ;
61033   int result;
61034
61035   {
61036     try {
61037       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61038     } catch (std::out_of_range& e) {
61039       {
61040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61041       };
61042     } catch (std::exception& e) {
61043       {
61044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61045       };
61046     } catch (Dali::DaliException e) {
61047       {
61048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61049       };
61050     } catch (...) {
61051       {
61052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61053       };
61054     }
61055   }
61056
61057   jresult = (int)result;
61058   return jresult;
61059 }
61060
61061
61062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61063   int jresult ;
61064   int result;
61065
61066   {
61067     try {
61068       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61069     } catch (std::out_of_range& e) {
61070       {
61071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61072       };
61073     } catch (std::exception& e) {
61074       {
61075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61076       };
61077     } catch (Dali::DaliException e) {
61078       {
61079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61080       };
61081     } catch (...) {
61082       {
61083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61084       };
61085     }
61086   }
61087
61088   jresult = (int)result;
61089   return jresult;
61090 }
61091
61092
61093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61094   int jresult ;
61095   int result;
61096
61097   {
61098     try {
61099       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61100     } catch (std::out_of_range& e) {
61101       {
61102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61103       };
61104     } catch (std::exception& e) {
61105       {
61106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61107       };
61108     } catch (Dali::DaliException e) {
61109       {
61110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61111       };
61112     } catch (...) {
61113       {
61114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61115       };
61116     }
61117   }
61118
61119   jresult = (int)result;
61120   return jresult;
61121 }
61122
61123
61124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61125   int jresult ;
61126   int result;
61127
61128   {
61129     try {
61130       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61131     } catch (std::out_of_range& e) {
61132       {
61133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61134       };
61135     } catch (std::exception& e) {
61136       {
61137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61138       };
61139     } catch (Dali::DaliException e) {
61140       {
61141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61142       };
61143     } catch (...) {
61144       {
61145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61146       };
61147     }
61148   }
61149
61150   jresult = (int)result;
61151   return jresult;
61152 }
61153
61154
61155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61156   int jresult ;
61157   int result;
61158
61159   {
61160     try {
61161       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61162     } catch (std::out_of_range& e) {
61163       {
61164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61165       };
61166     } catch (std::exception& e) {
61167       {
61168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61169       };
61170     } catch (Dali::DaliException e) {
61171       {
61172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61173       };
61174     } catch (...) {
61175       {
61176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61177       };
61178     }
61179   }
61180
61181   jresult = (int)result;
61182   return jresult;
61183 }
61184
61185
61186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61187   int jresult ;
61188   int result;
61189
61190   {
61191     try {
61192       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61193     } catch (std::out_of_range& e) {
61194       {
61195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61196       };
61197     } catch (std::exception& e) {
61198       {
61199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61200       };
61201     } catch (Dali::DaliException e) {
61202       {
61203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61204       };
61205     } catch (...) {
61206       {
61207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61208       };
61209     }
61210   }
61211
61212   jresult = (int)result;
61213   return jresult;
61214 }
61215
61216
61217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61218   int jresult ;
61219   int result;
61220
61221   {
61222     try {
61223       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61224     } catch (std::out_of_range& e) {
61225       {
61226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61227       };
61228     } catch (std::exception& e) {
61229       {
61230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61231       };
61232     } catch (Dali::DaliException e) {
61233       {
61234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61235       };
61236     } catch (...) {
61237       {
61238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61239       };
61240     }
61241   }
61242
61243   jresult = (int)result;
61244   return jresult;
61245 }
61246
61247
61248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61249   int jresult ;
61250   int result;
61251
61252   {
61253     try {
61254       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61255     } catch (std::out_of_range& e) {
61256       {
61257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61258       };
61259     } catch (std::exception& e) {
61260       {
61261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61262       };
61263     } catch (Dali::DaliException e) {
61264       {
61265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61266       };
61267     } catch (...) {
61268       {
61269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61270       };
61271     }
61272   }
61273
61274   jresult = (int)result;
61275   return jresult;
61276 }
61277
61278
61279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61280   int jresult ;
61281   int result;
61282
61283   {
61284     try {
61285       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61286     } catch (std::out_of_range& e) {
61287       {
61288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61289       };
61290     } catch (std::exception& e) {
61291       {
61292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61293       };
61294     } catch (Dali::DaliException e) {
61295       {
61296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61297       };
61298     } catch (...) {
61299       {
61300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61301       };
61302     }
61303   }
61304
61305   jresult = (int)result;
61306   return jresult;
61307 }
61308
61309
61310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61311   int jresult ;
61312   int result;
61313
61314   {
61315     try {
61316       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61317     } catch (std::out_of_range& e) {
61318       {
61319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61320       };
61321     } catch (std::exception& e) {
61322       {
61323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61324       };
61325     } catch (Dali::DaliException e) {
61326       {
61327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61328       };
61329     } catch (...) {
61330       {
61331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61332       };
61333     }
61334   }
61335
61336   jresult = (int)result;
61337   return jresult;
61338 }
61339
61340
61341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61342   int jresult ;
61343   int result;
61344
61345   {
61346     try {
61347       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61348     } catch (std::out_of_range& e) {
61349       {
61350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61351       };
61352     } catch (std::exception& e) {
61353       {
61354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (Dali::DaliException e) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61363       };
61364     }
61365   }
61366
61367   jresult = (int)result;
61368   return jresult;
61369 }
61370
61371
61372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61373   int jresult ;
61374   int result;
61375
61376   {
61377     try {
61378       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61379     } catch (std::out_of_range& e) {
61380       {
61381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61382       };
61383     } catch (std::exception& e) {
61384       {
61385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61386       };
61387     } catch (Dali::DaliException e) {
61388       {
61389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61394       };
61395     }
61396   }
61397
61398   jresult = (int)result;
61399   return jresult;
61400 }
61401
61402
61403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61404   int jresult ;
61405   int result;
61406
61407   {
61408     try {
61409       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61410     } catch (std::out_of_range& e) {
61411       {
61412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (std::exception& e) {
61415       {
61416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (Dali::DaliException e) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61421       };
61422     } catch (...) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61425       };
61426     }
61427   }
61428
61429   jresult = (int)result;
61430   return jresult;
61431 }
61432
61433
61434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61435   int jresult ;
61436   int result;
61437
61438   {
61439     try {
61440       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61441     } catch (std::out_of_range& e) {
61442       {
61443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61444       };
61445     } catch (std::exception& e) {
61446       {
61447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61448       };
61449     } catch (Dali::DaliException e) {
61450       {
61451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61452       };
61453     } catch (...) {
61454       {
61455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61456       };
61457     }
61458   }
61459
61460   jresult = (int)result;
61461   return jresult;
61462 }
61463
61464
61465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61466   int jresult ;
61467   int result;
61468
61469   {
61470     try {
61471       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61472     } catch (std::out_of_range& e) {
61473       {
61474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61475       };
61476     } catch (std::exception& e) {
61477       {
61478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61479       };
61480     } catch (Dali::DaliException e) {
61481       {
61482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61483       };
61484     } catch (...) {
61485       {
61486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61487       };
61488     }
61489   }
61490
61491   jresult = (int)result;
61492   return jresult;
61493 }
61494
61495
61496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61497   int jresult ;
61498   int result;
61499
61500   {
61501     try {
61502       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61503     } catch (std::out_of_range& e) {
61504       {
61505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61506       };
61507     } catch (std::exception& e) {
61508       {
61509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (Dali::DaliException e) {
61512       {
61513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61514       };
61515     } catch (...) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61518       };
61519     }
61520   }
61521
61522   jresult = (int)result;
61523   return jresult;
61524 }
61525
61526
61527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61528   int jresult ;
61529   int result;
61530
61531   {
61532     try {
61533       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61534     } catch (std::out_of_range& e) {
61535       {
61536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61537       };
61538     } catch (std::exception& e) {
61539       {
61540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61541       };
61542     } catch (Dali::DaliException e) {
61543       {
61544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61545       };
61546     } catch (...) {
61547       {
61548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61549       };
61550     }
61551   }
61552
61553   jresult = (int)result;
61554   return jresult;
61555 }
61556
61557
61558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61559   void * jresult ;
61560   Dali::Toolkit::Builder *result = 0 ;
61561
61562   {
61563     try {
61564       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61565     } catch (std::out_of_range& e) {
61566       {
61567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61568       };
61569     } catch (std::exception& e) {
61570       {
61571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61572       };
61573     } catch (Dali::DaliException e) {
61574       {
61575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61576       };
61577     } catch (...) {
61578       {
61579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61580       };
61581     }
61582   }
61583
61584   jresult = (void *)result;
61585   return jresult;
61586 }
61587
61588
61589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61590   void * jresult ;
61591   Dali::Toolkit::Builder result;
61592
61593   {
61594     try {
61595       result = Dali::Toolkit::Builder::New();
61596     } catch (std::out_of_range& e) {
61597       {
61598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61599       };
61600     } catch (std::exception& e) {
61601       {
61602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61603       };
61604     } catch (Dali::DaliException e) {
61605       {
61606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61607       };
61608     } catch (...) {
61609       {
61610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61611       };
61612     }
61613   }
61614
61615   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61616   return jresult;
61617 }
61618
61619
61620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61621   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61622
61623   arg1 = (Dali::Toolkit::Builder *)jarg1;
61624   {
61625     try {
61626       delete arg1;
61627     } catch (std::out_of_range& e) {
61628       {
61629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61630       };
61631     } catch (std::exception& e) {
61632       {
61633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61634       };
61635     } catch (Dali::DaliException e) {
61636       {
61637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61638       };
61639     } catch (...) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61642       };
61643     }
61644   }
61645
61646 }
61647
61648
61649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61651   std::string *arg2 = 0 ;
61652   Dali::Toolkit::Builder::UIFormat arg3 ;
61653
61654   arg1 = (Dali::Toolkit::Builder *)jarg1;
61655   if (!jarg2) {
61656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61657     return ;
61658   }
61659   std::string arg2_str(jarg2);
61660   arg2 = &arg2_str;
61661   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61662   {
61663     try {
61664       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61665     } catch (std::out_of_range& e) {
61666       {
61667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61668       };
61669     } catch (std::exception& e) {
61670       {
61671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61672       };
61673     } catch (Dali::DaliException e) {
61674       {
61675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61676       };
61677     } catch (...) {
61678       {
61679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61680       };
61681     }
61682   }
61683
61684
61685   //argout typemap for const std::string&
61686
61687 }
61688
61689
61690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61691   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61692   std::string *arg2 = 0 ;
61693
61694   arg1 = (Dali::Toolkit::Builder *)jarg1;
61695   if (!jarg2) {
61696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61697     return ;
61698   }
61699   std::string arg2_str(jarg2);
61700   arg2 = &arg2_str;
61701   {
61702     try {
61703       (arg1)->LoadFromString((std::string const &)*arg2);
61704     } catch (std::out_of_range& e) {
61705       {
61706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61707       };
61708     } catch (std::exception& e) {
61709       {
61710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61711       };
61712     } catch (Dali::DaliException e) {
61713       {
61714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61715       };
61716     } catch (...) {
61717       {
61718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61719       };
61720     }
61721   }
61722
61723
61724   //argout typemap for const std::string&
61725
61726 }
61727
61728
61729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61730   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61731   Dali::Property::Map *arg2 = 0 ;
61732
61733   arg1 = (Dali::Toolkit::Builder *)jarg1;
61734   arg2 = (Dali::Property::Map *)jarg2;
61735   if (!arg2) {
61736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61737     return ;
61738   }
61739   {
61740     try {
61741       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61742     } catch (std::out_of_range& e) {
61743       {
61744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61745       };
61746     } catch (std::exception& e) {
61747       {
61748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61749       };
61750     } catch (Dali::DaliException e) {
61751       {
61752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61753       };
61754     } catch (...) {
61755       {
61756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61757       };
61758     }
61759   }
61760
61761 }
61762
61763
61764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61765   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61766   std::string *arg2 = 0 ;
61767   Dali::Property::Value *arg3 = 0 ;
61768
61769   arg1 = (Dali::Toolkit::Builder *)jarg1;
61770   if (!jarg2) {
61771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61772     return ;
61773   }
61774   std::string arg2_str(jarg2);
61775   arg2 = &arg2_str;
61776   arg3 = (Dali::Property::Value *)jarg3;
61777   if (!arg3) {
61778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61779     return ;
61780   }
61781   {
61782     try {
61783       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61784     } catch (std::out_of_range& e) {
61785       {
61786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61787       };
61788     } catch (std::exception& e) {
61789       {
61790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61791       };
61792     } catch (Dali::DaliException e) {
61793       {
61794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61795       };
61796     } catch (...) {
61797       {
61798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61799       };
61800     }
61801   }
61802
61803
61804   //argout typemap for const std::string&
61805
61806 }
61807
61808
61809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61810   void * jresult ;
61811   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61812   Dali::Property::Map *result = 0 ;
61813
61814   arg1 = (Dali::Toolkit::Builder *)jarg1;
61815   {
61816     try {
61817       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61818     } catch (std::out_of_range& e) {
61819       {
61820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61821       };
61822     } catch (std::exception& e) {
61823       {
61824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61825       };
61826     } catch (Dali::DaliException e) {
61827       {
61828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61829       };
61830     } catch (...) {
61831       {
61832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61833       };
61834     }
61835   }
61836
61837   jresult = (void *)result;
61838   return jresult;
61839 }
61840
61841
61842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61843   void * jresult ;
61844   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61845   std::string *arg2 = 0 ;
61846   Dali::Property::Value *result = 0 ;
61847
61848   arg1 = (Dali::Toolkit::Builder *)jarg1;
61849   if (!jarg2) {
61850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61851     return 0;
61852   }
61853   std::string arg2_str(jarg2);
61854   arg2 = &arg2_str;
61855   {
61856     try {
61857       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61858     } catch (std::out_of_range& e) {
61859       {
61860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61861       };
61862     } catch (std::exception& e) {
61863       {
61864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61865       };
61866     } catch (Dali::DaliException e) {
61867       {
61868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61869       };
61870     } catch (...) {
61871       {
61872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61873       };
61874     }
61875   }
61876
61877   jresult = (void *)result;
61878
61879   //argout typemap for const std::string&
61880
61881   return jresult;
61882 }
61883
61884
61885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61886   void * jresult ;
61887   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61888   std::string *arg2 = 0 ;
61889   Dali::Animation result;
61890
61891   arg1 = (Dali::Toolkit::Builder *)jarg1;
61892   if (!jarg2) {
61893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61894     return 0;
61895   }
61896   std::string arg2_str(jarg2);
61897   arg2 = &arg2_str;
61898   {
61899     try {
61900       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61901     } catch (std::out_of_range& e) {
61902       {
61903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61904       };
61905     } catch (std::exception& e) {
61906       {
61907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61908       };
61909     } catch (Dali::DaliException e) {
61910       {
61911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61912       };
61913     } catch (...) {
61914       {
61915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61916       };
61917     }
61918   }
61919
61920   jresult = new Dali::Animation((const Dali::Animation &)result);
61921
61922   //argout typemap for const std::string&
61923
61924   return jresult;
61925 }
61926
61927
61928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61929   void * jresult ;
61930   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61931   std::string *arg2 = 0 ;
61932   Dali::Property::Map *arg3 = 0 ;
61933   Dali::Animation result;
61934
61935   arg1 = (Dali::Toolkit::Builder *)jarg1;
61936   if (!jarg2) {
61937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61938     return 0;
61939   }
61940   std::string arg2_str(jarg2);
61941   arg2 = &arg2_str;
61942   arg3 = (Dali::Property::Map *)jarg3;
61943   if (!arg3) {
61944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61945     return 0;
61946   }
61947   {
61948     try {
61949       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61950     } catch (std::out_of_range& e) {
61951       {
61952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61953       };
61954     } catch (std::exception& e) {
61955       {
61956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61957       };
61958     } catch (Dali::DaliException e) {
61959       {
61960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61961       };
61962     } catch (...) {
61963       {
61964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61965       };
61966     }
61967   }
61968
61969   jresult = new Dali::Animation((const Dali::Animation &)result);
61970
61971   //argout typemap for const std::string&
61972
61973   return jresult;
61974 }
61975
61976
61977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61978   void * jresult ;
61979   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61980   std::string *arg2 = 0 ;
61981   Dali::Actor arg3 ;
61982   Dali::Actor *argp3 ;
61983   Dali::Animation result;
61984
61985   arg1 = (Dali::Toolkit::Builder *)jarg1;
61986   if (!jarg2) {
61987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61988     return 0;
61989   }
61990   std::string arg2_str(jarg2);
61991   arg2 = &arg2_str;
61992   argp3 = (Dali::Actor *)jarg3;
61993   if (!argp3) {
61994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61995     return 0;
61996   }
61997   arg3 = *argp3;
61998   {
61999     try {
62000       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62001     } catch (std::out_of_range& e) {
62002       {
62003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62004       };
62005     } catch (std::exception& e) {
62006       {
62007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62008       };
62009     } catch (Dali::DaliException e) {
62010       {
62011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62012       };
62013     } catch (...) {
62014       {
62015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62016       };
62017     }
62018   }
62019
62020   jresult = new Dali::Animation((const Dali::Animation &)result);
62021
62022   //argout typemap for const std::string&
62023
62024   return jresult;
62025 }
62026
62027
62028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62029   void * jresult ;
62030   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62031   std::string *arg2 = 0 ;
62032   Dali::Property::Map *arg3 = 0 ;
62033   Dali::Actor arg4 ;
62034   Dali::Actor *argp4 ;
62035   Dali::Animation result;
62036
62037   arg1 = (Dali::Toolkit::Builder *)jarg1;
62038   if (!jarg2) {
62039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62040     return 0;
62041   }
62042   std::string arg2_str(jarg2);
62043   arg2 = &arg2_str;
62044   arg3 = (Dali::Property::Map *)jarg3;
62045   if (!arg3) {
62046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62047     return 0;
62048   }
62049   argp4 = (Dali::Actor *)jarg4;
62050   if (!argp4) {
62051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62052     return 0;
62053   }
62054   arg4 = *argp4;
62055   {
62056     try {
62057       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62058     } catch (std::out_of_range& e) {
62059       {
62060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62061       };
62062     } catch (std::exception& e) {
62063       {
62064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62065       };
62066     } catch (Dali::DaliException e) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62069       };
62070     } catch (...) {
62071       {
62072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62073       };
62074     }
62075   }
62076
62077   jresult = new Dali::Animation((const Dali::Animation &)result);
62078
62079   //argout typemap for const std::string&
62080
62081   return jresult;
62082 }
62083
62084
62085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62086   void * jresult ;
62087   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62088   std::string *arg2 = 0 ;
62089   Dali::BaseHandle result;
62090
62091   arg1 = (Dali::Toolkit::Builder *)jarg1;
62092   if (!jarg2) {
62093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62094     return 0;
62095   }
62096   std::string arg2_str(jarg2);
62097   arg2 = &arg2_str;
62098   {
62099     try {
62100       result = (arg1)->Create((std::string const &)*arg2);
62101     } catch (std::out_of_range& e) {
62102       {
62103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62104       };
62105     } catch (std::exception& e) {
62106       {
62107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62108       };
62109     } catch (Dali::DaliException e) {
62110       {
62111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62112       };
62113     } catch (...) {
62114       {
62115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62116       };
62117     }
62118   }
62119
62120   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62121
62122   //argout typemap for const std::string&
62123
62124   return jresult;
62125 }
62126
62127
62128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62129   void * jresult ;
62130   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62131   std::string *arg2 = 0 ;
62132   Dali::Property::Map *arg3 = 0 ;
62133   Dali::BaseHandle result;
62134
62135   arg1 = (Dali::Toolkit::Builder *)jarg1;
62136   if (!jarg2) {
62137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62138     return 0;
62139   }
62140   std::string arg2_str(jarg2);
62141   arg2 = &arg2_str;
62142   arg3 = (Dali::Property::Map *)jarg3;
62143   if (!arg3) {
62144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62145     return 0;
62146   }
62147   {
62148     try {
62149       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62150     } catch (std::out_of_range& e) {
62151       {
62152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62153       };
62154     } catch (std::exception& e) {
62155       {
62156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62157       };
62158     } catch (Dali::DaliException e) {
62159       {
62160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62161       };
62162     } catch (...) {
62163       {
62164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62165       };
62166     }
62167   }
62168
62169   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62170
62171   //argout typemap for const std::string&
62172
62173   return jresult;
62174 }
62175
62176
62177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62178   void * jresult ;
62179   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62180   std::string *arg2 = 0 ;
62181   Dali::BaseHandle result;
62182
62183   arg1 = (Dali::Toolkit::Builder *)jarg1;
62184   if (!jarg2) {
62185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62186     return 0;
62187   }
62188   std::string arg2_str(jarg2);
62189   arg2 = &arg2_str;
62190   {
62191     try {
62192       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62200       };
62201     } catch (Dali::DaliException e) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62204       };
62205     } catch (...) {
62206       {
62207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62208       };
62209     }
62210   }
62211
62212   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62213
62214   //argout typemap for const std::string&
62215
62216   return jresult;
62217 }
62218
62219
62220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62221   unsigned int jresult ;
62222   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62223   std::string *arg2 = 0 ;
62224   Dali::Handle *arg3 = 0 ;
62225   bool result;
62226
62227   arg1 = (Dali::Toolkit::Builder *)jarg1;
62228   if (!jarg2) {
62229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62230     return 0;
62231   }
62232   std::string arg2_str(jarg2);
62233   arg2 = &arg2_str;
62234   arg3 = (Dali::Handle *)jarg3;
62235   if (!arg3) {
62236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62237     return 0;
62238   }
62239   {
62240     try {
62241       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62242     } catch (std::out_of_range& e) {
62243       {
62244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62245       };
62246     } catch (std::exception& e) {
62247       {
62248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62249       };
62250     } catch (Dali::DaliException e) {
62251       {
62252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62253       };
62254     } catch (...) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62257       };
62258     }
62259   }
62260
62261   jresult = result;
62262
62263   //argout typemap for const std::string&
62264
62265   return jresult;
62266 }
62267
62268
62269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62270   unsigned int jresult ;
62271   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62272   Dali::Handle *arg2 = 0 ;
62273   std::string *arg3 = 0 ;
62274   bool result;
62275
62276   arg1 = (Dali::Toolkit::Builder *)jarg1;
62277   arg2 = (Dali::Handle *)jarg2;
62278   if (!arg2) {
62279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62280     return 0;
62281   }
62282   if (!jarg3) {
62283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62284     return 0;
62285   }
62286   std::string arg3_str(jarg3);
62287   arg3 = &arg3_str;
62288   {
62289     try {
62290       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62291     } catch (std::out_of_range& e) {
62292       {
62293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62294       };
62295     } catch (std::exception& e) {
62296       {
62297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62298       };
62299     } catch (Dali::DaliException e) {
62300       {
62301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62302       };
62303     } catch (...) {
62304       {
62305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62306       };
62307     }
62308   }
62309
62310   jresult = result;
62311
62312   //argout typemap for const std::string&
62313
62314   return jresult;
62315 }
62316
62317
62318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62319   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62320   Dali::Actor arg2 ;
62321   Dali::Actor *argp2 ;
62322
62323   arg1 = (Dali::Toolkit::Builder *)jarg1;
62324   argp2 = (Dali::Actor *)jarg2;
62325   if (!argp2) {
62326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62327     return ;
62328   }
62329   arg2 = *argp2;
62330   {
62331     try {
62332       (arg1)->AddActors(arg2);
62333     } catch (std::out_of_range& e) {
62334       {
62335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62336       };
62337     } catch (std::exception& e) {
62338       {
62339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62340       };
62341     } catch (Dali::DaliException e) {
62342       {
62343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62344       };
62345     } catch (...) {
62346       {
62347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62348       };
62349     }
62350   }
62351
62352 }
62353
62354
62355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62356   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62357   std::string *arg2 = 0 ;
62358   Dali::Actor arg3 ;
62359   Dali::Actor *argp3 ;
62360
62361   arg1 = (Dali::Toolkit::Builder *)jarg1;
62362   if (!jarg2) {
62363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62364     return ;
62365   }
62366   std::string arg2_str(jarg2);
62367   arg2 = &arg2_str;
62368   argp3 = (Dali::Actor *)jarg3;
62369   if (!argp3) {
62370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62371     return ;
62372   }
62373   arg3 = *argp3;
62374   {
62375     try {
62376       (arg1)->AddActors((std::string const &)*arg2,arg3);
62377     } catch (std::out_of_range& e) {
62378       {
62379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62380       };
62381     } catch (std::exception& e) {
62382       {
62383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62384       };
62385     } catch (Dali::DaliException e) {
62386       {
62387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62388       };
62389     } catch (...) {
62390       {
62391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62392       };
62393     }
62394   }
62395
62396
62397   //argout typemap for const std::string&
62398
62399 }
62400
62401
62402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62403   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62404   std::string *arg2 = 0 ;
62405
62406   arg1 = (Dali::Toolkit::Builder *)jarg1;
62407   if (!jarg2) {
62408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62409     return ;
62410   }
62411   std::string arg2_str(jarg2);
62412   arg2 = &arg2_str;
62413   {
62414     try {
62415       (arg1)->CreateRenderTask((std::string const &)*arg2);
62416     } catch (std::out_of_range& e) {
62417       {
62418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62419       };
62420     } catch (std::exception& e) {
62421       {
62422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62423       };
62424     } catch (Dali::DaliException e) {
62425       {
62426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62427       };
62428     } catch (...) {
62429       {
62430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62431       };
62432     }
62433   }
62434
62435
62436   //argout typemap for const std::string&
62437
62438 }
62439
62440
62441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62442   void * jresult ;
62443   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62444   std::string *arg2 = 0 ;
62445   Dali::FrameBufferImage result;
62446
62447   arg1 = (Dali::Toolkit::Builder *)jarg1;
62448   if (!jarg2) {
62449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62450     return 0;
62451   }
62452   std::string arg2_str(jarg2);
62453   arg2 = &arg2_str;
62454   {
62455     try {
62456       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62457     } catch (std::out_of_range& e) {
62458       {
62459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62460       };
62461     } catch (std::exception& e) {
62462       {
62463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62464       };
62465     } catch (Dali::DaliException e) {
62466       {
62467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62468       };
62469     } catch (...) {
62470       {
62471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62472       };
62473     }
62474   }
62475
62476   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62477
62478   //argout typemap for const std::string&
62479
62480   return jresult;
62481 }
62482
62483
62484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62485   void * jresult ;
62486   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62487   std::string *arg2 = 0 ;
62488   Dali::Path result;
62489
62490   arg1 = (Dali::Toolkit::Builder *)jarg1;
62491   if (!jarg2) {
62492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62493     return 0;
62494   }
62495   std::string arg2_str(jarg2);
62496   arg2 = &arg2_str;
62497   {
62498     try {
62499       result = (arg1)->GetPath((std::string const &)*arg2);
62500     } catch (std::out_of_range& e) {
62501       {
62502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62503       };
62504     } catch (std::exception& e) {
62505       {
62506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62507       };
62508     } catch (Dali::DaliException e) {
62509       {
62510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62511       };
62512     } catch (...) {
62513       {
62514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62515       };
62516     }
62517   }
62518
62519   jresult = new Dali::Path((const Dali::Path &)result);
62520
62521   //argout typemap for const std::string&
62522
62523   return jresult;
62524 }
62525
62526
62527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62528   void * jresult ;
62529   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62530   std::string *arg2 = 0 ;
62531   Dali::PathConstrainer result;
62532
62533   arg1 = (Dali::Toolkit::Builder *)jarg1;
62534   if (!jarg2) {
62535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62536     return 0;
62537   }
62538   std::string arg2_str(jarg2);
62539   arg2 = &arg2_str;
62540   {
62541     try {
62542       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62543     } catch (std::out_of_range& e) {
62544       {
62545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62546       };
62547     } catch (std::exception& e) {
62548       {
62549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62550       };
62551     } catch (Dali::DaliException e) {
62552       {
62553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62554       };
62555     } catch (...) {
62556       {
62557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62558       };
62559     }
62560   }
62561
62562   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62563
62564   //argout typemap for const std::string&
62565
62566   return jresult;
62567 }
62568
62569
62570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62571   void * jresult ;
62572   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62573   std::string *arg2 = 0 ;
62574   Dali::LinearConstrainer result;
62575
62576   arg1 = (Dali::Toolkit::Builder *)jarg1;
62577   if (!jarg2) {
62578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62579     return 0;
62580   }
62581   std::string arg2_str(jarg2);
62582   arg2 = &arg2_str;
62583   {
62584     try {
62585       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62586     } catch (std::out_of_range& e) {
62587       {
62588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62589       };
62590     } catch (std::exception& e) {
62591       {
62592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62593       };
62594     } catch (Dali::DaliException e) {
62595       {
62596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62597       };
62598     } catch (...) {
62599       {
62600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62601       };
62602     }
62603   }
62604
62605   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62606
62607   //argout typemap for const std::string&
62608
62609   return jresult;
62610 }
62611
62612
62613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62614   void * jresult ;
62615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62616   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62617
62618   arg1 = (Dali::Toolkit::Builder *)jarg1;
62619   {
62620     try {
62621       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62622     } catch (std::out_of_range& e) {
62623       {
62624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (std::exception& e) {
62627       {
62628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62629       };
62630     } catch (Dali::DaliException e) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62633       };
62634     } catch (...) {
62635       {
62636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62637       };
62638     }
62639   }
62640
62641   jresult = (void *)result;
62642   return jresult;
62643 }
62644
62645
62646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62647   void * jresult ;
62648   Dali::Toolkit::TransitionData *result = 0 ;
62649
62650   {
62651     try {
62652       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62653     } catch (std::out_of_range& e) {
62654       {
62655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62656       };
62657     } catch (std::exception& e) {
62658       {
62659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62660       };
62661     } catch (Dali::DaliException e) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62664       };
62665     } catch (...) {
62666       {
62667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62668       };
62669     }
62670   }
62671
62672   jresult = (void *)result;
62673   return jresult;
62674 }
62675
62676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62677   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62678
62679   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62680   {
62681     try {
62682       delete arg1;
62683     } catch (std::out_of_range& e) {
62684       {
62685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62686       };
62687     } catch (std::exception& e) {
62688       {
62689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62690       };
62691     } catch (Dali::DaliException e) {
62692       {
62693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62694       };
62695     } catch (...) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62698       };
62699     }
62700   }
62701
62702 }
62703
62704
62705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62706   void * jresult ;
62707   Dali::Property::Map *arg1 = 0 ;
62708   Dali::Toolkit::TransitionData result;
62709
62710   arg1 = (Dali::Property::Map *)jarg1;
62711   if (!arg1) {
62712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62713     return 0;
62714   }
62715   {
62716     try {
62717       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62733       };
62734     }
62735   }
62736
62737   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62743   void * jresult ;
62744   Dali::Property::Array *arg1 = 0 ;
62745   Dali::Toolkit::TransitionData result;
62746
62747   arg1 = (Dali::Property::Array *)jarg1;
62748   if (!arg1) {
62749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62750     return 0;
62751   }
62752   {
62753     try {
62754       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62755     } catch (std::out_of_range& e) {
62756       {
62757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62758       };
62759     } catch (std::exception& e) {
62760       {
62761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62762       };
62763     } catch (Dali::DaliException e) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62766       };
62767     } catch (...) {
62768       {
62769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62770       };
62771     }
62772   }
62773
62774   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62775   return jresult;
62776 }
62777
62778
62779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62780   void * jresult ;
62781   Dali::BaseHandle arg1 ;
62782   Dali::BaseHandle *argp1 ;
62783   Dali::Toolkit::TransitionData result;
62784
62785   argp1 = (Dali::BaseHandle *)jarg1;
62786   if (!argp1) {
62787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62788     return 0;
62789   }
62790   arg1 = *argp1;
62791   {
62792     try {
62793       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62794     } catch (std::out_of_range& e) {
62795       {
62796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62797       };
62798     } catch (std::exception& e) {
62799       {
62800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62801       };
62802     } catch (Dali::DaliException e) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62805       };
62806     } catch (...) {
62807       {
62808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62809       };
62810     }
62811   }
62812
62813   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62814   return jresult;
62815 }
62816
62817
62818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62819   void * jresult ;
62820   Dali::Toolkit::TransitionData *arg1 = 0 ;
62821   Dali::Toolkit::TransitionData *result = 0 ;
62822
62823   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62824   if (!arg1) {
62825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62826     return 0;
62827   }
62828   {
62829     try {
62830       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62831     } catch (std::out_of_range& e) {
62832       {
62833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (std::exception& e) {
62836       {
62837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62838       };
62839     } catch (Dali::DaliException e) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62842       };
62843     } catch (...) {
62844       {
62845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62846       };
62847     }
62848   }
62849
62850   jresult = (void *)result;
62851   return jresult;
62852 }
62853
62854
62855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62856   void * jresult ;
62857   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62858   Dali::Toolkit::TransitionData *arg2 = 0 ;
62859   Dali::Toolkit::TransitionData *result = 0 ;
62860
62861   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62862   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62863   if (!arg2) {
62864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62865     return 0;
62866   }
62867   {
62868     try {
62869       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62870     } catch (std::out_of_range& e) {
62871       {
62872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62873       };
62874     } catch (std::exception& e) {
62875       {
62876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62877       };
62878     } catch (Dali::DaliException e) {
62879       {
62880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62881       };
62882     } catch (...) {
62883       {
62884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62885       };
62886     }
62887   }
62888
62889   jresult = (void *)result;
62890   return jresult;
62891 }
62892
62893
62894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62895   unsigned long jresult ;
62896   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62897   size_t result;
62898
62899   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62900   {
62901     try {
62902       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62903     } catch (std::out_of_range& e) {
62904       {
62905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (std::exception& e) {
62908       {
62909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62910       };
62911     } catch (Dali::DaliException e) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62918       };
62919     }
62920   }
62921
62922   jresult = (unsigned long)result;
62923   return jresult;
62924 }
62925
62926
62927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62928   void * jresult ;
62929   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62930   size_t arg2 ;
62931   Dali::Property::Map result;
62932
62933   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62934   arg2 = (size_t)jarg2;
62935   {
62936     try {
62937       result = (arg1)->GetAnimatorAt(arg2);
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (Dali::DaliException e) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62949       };
62950     } catch (...) {
62951       {
62952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62953       };
62954     }
62955   }
62956
62957   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62958   return jresult;
62959 }
62960
62961
62962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62963   int jresult ;
62964   int result;
62965
62966   {
62967     try {
62968       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62969     } catch (std::out_of_range& e) {
62970       {
62971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62972       };
62973     } catch (std::exception& e) {
62974       {
62975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62976       };
62977     } catch (Dali::DaliException e) {
62978       {
62979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62980       };
62981     } catch (...) {
62982       {
62983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62984       };
62985     }
62986   }
62987
62988   jresult = (int)result;
62989   return jresult;
62990 }
62991
62992
62993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62994   int jresult ;
62995   int result;
62996
62997   {
62998     try {
62999       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63000     } catch (std::out_of_range& e) {
63001       {
63002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (std::exception& e) {
63005       {
63006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (Dali::DaliException e) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63011       };
63012     } catch (...) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63015       };
63016     }
63017   }
63018
63019   jresult = (int)result;
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63025   int jresult ;
63026   int result;
63027
63028   {
63029     try {
63030       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63031     } catch (std::out_of_range& e) {
63032       {
63033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63034       };
63035     } catch (std::exception& e) {
63036       {
63037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (Dali::DaliException e) {
63040       {
63041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63042       };
63043     } catch (...) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63046       };
63047     }
63048   }
63049
63050   jresult = (int)result;
63051   return jresult;
63052 }
63053
63054
63055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63056   int jresult ;
63057   int result;
63058
63059   {
63060     try {
63061       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63062     } catch (std::out_of_range& e) {
63063       {
63064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63065       };
63066     } catch (std::exception& e) {
63067       {
63068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63069       };
63070     } catch (Dali::DaliException e) {
63071       {
63072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63077       };
63078     }
63079   }
63080
63081   jresult = (int)result;
63082   return jresult;
63083 }
63084
63085
63086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63087   int jresult ;
63088   int result;
63089
63090   {
63091     try {
63092       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63093     } catch (std::out_of_range& e) {
63094       {
63095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63096       };
63097     } catch (std::exception& e) {
63098       {
63099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63100       };
63101     } catch (Dali::DaliException e) {
63102       {
63103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63108       };
63109     }
63110   }
63111
63112   jresult = (int)result;
63113   return jresult;
63114 }
63115
63116
63117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63118   int jresult ;
63119   int result;
63120
63121   {
63122     try {
63123       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63124     } catch (std::out_of_range& e) {
63125       {
63126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63127       };
63128     } catch (std::exception& e) {
63129       {
63130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (Dali::DaliException e) {
63133       {
63134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142
63143   jresult = (int)result;
63144   return jresult;
63145 }
63146
63147
63148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63149   int jresult ;
63150   int result;
63151
63152   {
63153     try {
63154       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63170       };
63171     }
63172   }
63173
63174   jresult = (int)result;
63175   return jresult;
63176 }
63177
63178
63179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63180   int jresult ;
63181   int result;
63182
63183   {
63184     try {
63185       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (Dali::DaliException e) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63197       };
63198     } catch (...) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63201       };
63202     }
63203   }
63204
63205   jresult = (int)result;
63206   return jresult;
63207 }
63208
63209
63210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63211   int jresult ;
63212   int result;
63213
63214   {
63215     try {
63216       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63224       };
63225     } catch (Dali::DaliException e) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63232       };
63233     }
63234   }
63235
63236   jresult = (int)result;
63237   return jresult;
63238 }
63239
63240
63241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63242   int jresult ;
63243   int result;
63244
63245   {
63246     try {
63247       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (Dali::DaliException e) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63259       };
63260     } catch (...) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63263       };
63264     }
63265   }
63266
63267   jresult = (int)result;
63268   return jresult;
63269 }
63270
63271
63272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63273   int jresult ;
63274   int result;
63275
63276   {
63277     try {
63278       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63279     } catch (std::out_of_range& e) {
63280       {
63281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63282       };
63283     } catch (std::exception& e) {
63284       {
63285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63286       };
63287     } catch (Dali::DaliException e) {
63288       {
63289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63290       };
63291     } catch (...) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63294       };
63295     }
63296   }
63297
63298   jresult = (int)result;
63299   return jresult;
63300 }
63301
63302
63303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63304   int jresult ;
63305   int result;
63306
63307   {
63308     try {
63309       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63310     } catch (std::out_of_range& e) {
63311       {
63312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63313       };
63314     } catch (std::exception& e) {
63315       {
63316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (Dali::DaliException e) {
63319       {
63320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328
63329   jresult = (int)result;
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63335   int jresult ;
63336   int result;
63337
63338   {
63339     try {
63340       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63341     } catch (std::out_of_range& e) {
63342       {
63343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (std::exception& e) {
63346       {
63347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (Dali::DaliException e) {
63350       {
63351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63356       };
63357     }
63358   }
63359
63360   jresult = (int)result;
63361   return jresult;
63362 }
63363
63364
63365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63366   int jresult ;
63367   int result;
63368
63369   {
63370     try {
63371       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63372     } catch (std::out_of_range& e) {
63373       {
63374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63375       };
63376     } catch (std::exception& e) {
63377       {
63378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (Dali::DaliException e) {
63381       {
63382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63387       };
63388     }
63389   }
63390
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63397   void * jresult ;
63398   Dali::Toolkit::Control result;
63399
63400   {
63401     try {
63402       result = Dali::Toolkit::Internal::Control::New();
63403     } catch (std::out_of_range& e) {
63404       {
63405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (std::exception& e) {
63408       {
63409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (Dali::DaliException e) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63418       };
63419     }
63420   }
63421
63422   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63423   return jresult;
63424 }
63425
63426
63427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63429   std::string *arg2 = 0 ;
63430
63431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63432   if (!jarg2) {
63433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63434     return ;
63435   }
63436   std::string arg2_str(jarg2);
63437   arg2 = &arg2_str;
63438   {
63439     try {
63440       (arg1)->SetStyleName((std::string const &)*arg2);
63441     } catch (std::out_of_range& e) {
63442       {
63443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63444       };
63445     } catch (std::exception& e) {
63446       {
63447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63448       };
63449     } catch (Dali::DaliException e) {
63450       {
63451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63452       };
63453     } catch (...) {
63454       {
63455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63456       };
63457     }
63458   }
63459
63460
63461   //argout typemap for const std::string&
63462
63463 }
63464
63465
63466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63467   char * jresult ;
63468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63469   std::string *result = 0 ;
63470
63471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63472   {
63473     try {
63474       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63475     } catch (std::out_of_range& e) {
63476       {
63477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63478       };
63479     } catch (std::exception& e) {
63480       {
63481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63482       };
63483     } catch (Dali::DaliException e) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63486       };
63487     } catch (...) {
63488       {
63489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63490       };
63491     }
63492   }
63493
63494   jresult = SWIG_csharp_string_callback(result->c_str());
63495   return jresult;
63496 }
63497
63498
63499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63501   Dali::Vector4 *arg2 = 0 ;
63502
63503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63504   arg2 = (Dali::Vector4 *)jarg2;
63505   if (!arg2) {
63506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63507     return ;
63508   }
63509   {
63510     try {
63511       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63512     } catch (std::out_of_range& e) {
63513       {
63514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63515       };
63516     } catch (std::exception& e) {
63517       {
63518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63519       };
63520     } catch (Dali::DaliException e) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63523       };
63524     } catch (...) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63527       };
63528     }
63529   }
63530
63531 }
63532
63533
63534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63535   void * jresult ;
63536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63537   Dali::Vector4 result;
63538
63539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63540   {
63541     try {
63542       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63543     } catch (std::out_of_range& e) {
63544       {
63545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (std::exception& e) {
63548       {
63549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63550       };
63551     } catch (Dali::DaliException e) {
63552       {
63553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63554       };
63555     } catch (...) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63558       };
63559     }
63560   }
63561
63562   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63563   return jresult;
63564 }
63565
63566
63567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63569   Dali::Image arg2 ;
63570   Dali::Image *argp2 ;
63571
63572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63573   argp2 = (Dali::Image *)jarg2;
63574   if (!argp2) {
63575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63576     return ;
63577   }
63578   arg2 = *argp2;
63579   {
63580     try {
63581       (arg1)->SetBackgroundImage(arg2);
63582     } catch (std::out_of_range& e) {
63583       {
63584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63585       };
63586     } catch (std::exception& e) {
63587       {
63588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63589       };
63590     } catch (Dali::DaliException e) {
63591       {
63592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63593       };
63594     } catch (...) {
63595       {
63596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63597       };
63598     }
63599   }
63600
63601 }
63602
63603
63604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63606   Dali::Property::Map *arg2 = 0 ;
63607
63608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63609   arg2 = (Dali::Property::Map *)jarg2;
63610   if (!arg2) {
63611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63612     return ;
63613   }
63614   {
63615     try {
63616       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63617     } catch (std::out_of_range& e) {
63618       {
63619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63620       };
63621     } catch (std::exception& e) {
63622       {
63623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63624       };
63625     } catch (Dali::DaliException e) {
63626       {
63627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63628       };
63629     } catch (...) {
63630       {
63631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63632       };
63633     }
63634   }
63635
63636 }
63637
63638
63639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63641
63642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63643   {
63644     try {
63645       (arg1)->ClearBackground();
63646     } catch (std::out_of_range& e) {
63647       {
63648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63649       };
63650     } catch (std::exception& e) {
63651       {
63652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63653       };
63654     } catch (Dali::DaliException e) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63657       };
63658     } catch (...) {
63659       {
63660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63661       };
63662     }
63663   }
63664
63665 }
63666
63667
63668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63670   Dali::Gesture::Type arg2 ;
63671
63672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63673   arg2 = (Dali::Gesture::Type)jarg2;
63674   {
63675     try {
63676       (arg1)->EnableGestureDetection(arg2);
63677     } catch (std::out_of_range& e) {
63678       {
63679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63680       };
63681     } catch (std::exception& e) {
63682       {
63683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63684       };
63685     } catch (Dali::DaliException e) {
63686       {
63687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63688       };
63689     } catch (...) {
63690       {
63691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63692       };
63693     }
63694   }
63695
63696 }
63697
63698
63699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63701   Dali::Gesture::Type arg2 ;
63702
63703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63704   arg2 = (Dali::Gesture::Type)jarg2;
63705   {
63706     try {
63707       (arg1)->DisableGestureDetection(arg2);
63708     } catch (std::out_of_range& e) {
63709       {
63710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63711       };
63712     } catch (std::exception& e) {
63713       {
63714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63715       };
63716     } catch (Dali::DaliException e) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63719       };
63720     } catch (...) {
63721       {
63722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63723       };
63724     }
63725   }
63726
63727 }
63728
63729
63730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63731   void * jresult ;
63732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63733   Dali::PinchGestureDetector result;
63734
63735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63736   {
63737     try {
63738       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63746       };
63747     } catch (Dali::DaliException e) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63750       };
63751     } catch (...) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63754       };
63755     }
63756   }
63757
63758   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63759   return jresult;
63760 }
63761
63762
63763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63764   void * jresult ;
63765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63766   Dali::PanGestureDetector result;
63767
63768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63769   {
63770     try {
63771       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63772     } catch (std::out_of_range& e) {
63773       {
63774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63775       };
63776     } catch (std::exception& e) {
63777       {
63778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63779       };
63780     } catch (Dali::DaliException e) {
63781       {
63782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63783       };
63784     } catch (...) {
63785       {
63786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63787       };
63788     }
63789   }
63790
63791   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63792   return jresult;
63793 }
63794
63795
63796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63797   void * jresult ;
63798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63799   Dali::TapGestureDetector result;
63800
63801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63802   {
63803     try {
63804       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63805     } catch (std::out_of_range& e) {
63806       {
63807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (std::exception& e) {
63810       {
63811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63812       };
63813     } catch (Dali::DaliException e) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63816       };
63817     } catch (...) {
63818       {
63819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63820       };
63821     }
63822   }
63823
63824   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63825   return jresult;
63826 }
63827
63828
63829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63830   void * jresult ;
63831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63832   Dali::LongPressGestureDetector result;
63833
63834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63835   {
63836     try {
63837       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63838     } catch (std::out_of_range& e) {
63839       {
63840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (std::exception& e) {
63843       {
63844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63845       };
63846     } catch (Dali::DaliException e) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63849       };
63850     } catch (...) {
63851       {
63852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63853       };
63854     }
63855   }
63856
63857   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63858   return jresult;
63859 }
63860
63861
63862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63864   bool arg2 ;
63865
63866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63867   arg2 = jarg2 ? true : false;
63868   {
63869     try {
63870       (arg1)->SetKeyboardNavigationSupport(arg2);
63871     } catch (std::out_of_range& e) {
63872       {
63873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63874       };
63875     } catch (std::exception& e) {
63876       {
63877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63878       };
63879     } catch (Dali::DaliException e) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63882       };
63883     } catch (...) {
63884       {
63885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63886       };
63887     }
63888   }
63889
63890 }
63891
63892
63893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63894   unsigned int jresult ;
63895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63896   bool result;
63897
63898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63899   {
63900     try {
63901       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63902     } catch (std::out_of_range& e) {
63903       {
63904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63905       };
63906     } catch (std::exception& e) {
63907       {
63908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63909       };
63910     } catch (Dali::DaliException e) {
63911       {
63912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63913       };
63914     } catch (...) {
63915       {
63916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63917       };
63918     }
63919   }
63920
63921   jresult = result;
63922   return jresult;
63923 }
63924
63925
63926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63928
63929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63930   {
63931     try {
63932       (arg1)->SetKeyInputFocus();
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63940       };
63941     } catch (Dali::DaliException e) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63944       };
63945     } catch (...) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63948       };
63949     }
63950   }
63951
63952 }
63953
63954
63955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63956   unsigned int jresult ;
63957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63958   bool result;
63959
63960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63961   {
63962     try {
63963       result = (bool)(arg1)->HasKeyInputFocus();
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63979       };
63980     }
63981   }
63982
63983   jresult = result;
63984   return jresult;
63985 }
63986
63987
63988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63990
63991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63992   {
63993     try {
63994       (arg1)->ClearKeyInputFocus();
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (Dali::DaliException e) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64006       };
64007     } catch (...) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64010       };
64011     }
64012   }
64013
64014 }
64015
64016
64017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64019   bool arg2 ;
64020
64021   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64022   arg2 = jarg2 ? true : false;
64023   {
64024     try {
64025       (arg1)->SetAsKeyboardFocusGroup(arg2);
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64033       };
64034     } catch (Dali::DaliException e) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64037       };
64038     } catch (...) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64041       };
64042     }
64043   }
64044
64045 }
64046
64047
64048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64049   unsigned int jresult ;
64050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64051   bool result;
64052
64053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64054   {
64055     try {
64056       result = (bool)(arg1)->IsKeyboardFocusGroup();
64057     } catch (std::out_of_range& e) {
64058       {
64059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64060       };
64061     } catch (std::exception& e) {
64062       {
64063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64064       };
64065     } catch (Dali::DaliException e) {
64066       {
64067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64068       };
64069     } catch (...) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64072       };
64073     }
64074   }
64075
64076   jresult = result;
64077   return jresult;
64078 }
64079
64080
64081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64082   void * jresult ;
64083   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64084   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64085
64086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64087   {
64088     try {
64089       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64090     } catch (std::out_of_range& e) {
64091       {
64092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64093       };
64094     } catch (std::exception& e) {
64095       {
64096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64097       };
64098     } catch (Dali::DaliException e) {
64099       {
64100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64101       };
64102     } catch (...) {
64103       {
64104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64105       };
64106     }
64107   }
64108
64109   jresult = (void *)result;
64110   return jresult;
64111 }
64112
64113
64114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64115   void * jresult ;
64116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64117   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64118
64119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64120   {
64121     try {
64122       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (Dali::DaliException e) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141
64142   jresult = (void *)result;
64143   return jresult;
64144 }
64145
64146
64147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64148   void * jresult ;
64149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64150   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64151
64152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64153   {
64154     try {
64155       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64156     } catch (std::out_of_range& e) {
64157       {
64158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64159       };
64160     } catch (std::exception& e) {
64161       {
64162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64163       };
64164     } catch (Dali::DaliException e) {
64165       {
64166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64167       };
64168     } catch (...) {
64169       {
64170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64171       };
64172     }
64173   }
64174
64175   jresult = (void *)result;
64176   return jresult;
64177 }
64178
64179
64180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64182   int arg2 ;
64183   SwigDirector_ViewImpl *darg = 0;
64184
64185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64186   arg2 = (int)jarg2;
64187   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64188   if(!darg) {
64189     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64190     return;
64191   }
64192   {
64193     try {
64194       if(darg) {
64195         (darg)->OnStageConnection(arg2);
64196       }
64197     } catch (std::out_of_range& e) {
64198       {
64199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64200       };
64201     } catch (std::exception& e) {
64202       {
64203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64204       };
64205     } catch (Dali::DaliException e) {
64206       {
64207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64208       };
64209     } catch (...) {
64210       {
64211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64212       };
64213     }
64214   }
64215
64216 }
64217
64218
64219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64221   int arg2 ;
64222   SwigDirector_ViewImpl *darg = 0;
64223
64224   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64225   arg2 = (int)jarg2;
64226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64227   if(!darg) {
64228     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64229     return;
64230   }
64231   {
64232     try {
64233       if(darg) {
64234         (darg)->OnStageConnectionSwigPublic(arg2);
64235       }
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64243       };
64244     } catch (Dali::DaliException e) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64247       };
64248     } catch (...) {
64249       {
64250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64251       };
64252     }
64253   }
64254
64255 }
64256
64257
64258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64260   SwigDirector_ViewImpl *darg = 0;
64261
64262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64263   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64264   if(!darg) {
64265     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64266     return;
64267   }
64268   {
64269     try {
64270       if(darg) {
64271         (darg)->OnStageDisconnection();
64272       }
64273     } catch (std::out_of_range& e) {
64274       {
64275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64276       };
64277     } catch (std::exception& e) {
64278       {
64279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64280       };
64281     } catch (Dali::DaliException e) {
64282       {
64283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64284       };
64285     } catch (...) {
64286       {
64287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64288       };
64289     }
64290   }
64291
64292 }
64293
64294
64295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64297   SwigDirector_ViewImpl *darg = 0;
64298
64299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64301   if(!darg) {
64302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64303     return;
64304   }
64305   {
64306     try {
64307       if(darg) {
64308         (darg)->OnStageDisconnectionSwigPublic();
64309       }
64310     } catch (std::out_of_range& e) {
64311       {
64312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64313       };
64314     } catch (std::exception& e) {
64315       {
64316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64317       };
64318     } catch (Dali::DaliException e) {
64319       {
64320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64321       };
64322     } catch (...) {
64323       {
64324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64325       };
64326     }
64327   }
64328
64329 }
64330
64331
64332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64334   Dali::Actor *arg2 = 0 ;
64335   SwigDirector_ViewImpl *darg = 0;
64336
64337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64338   arg2 = (Dali::Actor *)jarg2;
64339   if (!arg2) {
64340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64341     return ;
64342   }
64343   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64344   if(!darg) {
64345     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64346     return;
64347   }
64348   {
64349     try {
64350       if(darg) {
64351         (darg)->OnChildAdd(*arg2);
64352       }
64353     } catch (std::out_of_range& e) {
64354       {
64355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64356       };
64357     } catch (std::exception& e) {
64358       {
64359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64360       };
64361     } catch (Dali::DaliException e) {
64362       {
64363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64364       };
64365     } catch (...) {
64366       {
64367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64368       };
64369     }
64370   }
64371
64372 }
64373
64374
64375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64377   Dali::Actor *arg2 = 0 ;
64378   SwigDirector_ViewImpl *darg = 0;
64379
64380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64381   arg2 = (Dali::Actor *)jarg2;
64382   if (!arg2) {
64383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64384     return ;
64385   }
64386   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64387   if(!darg) {
64388     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64389     return;
64390   }
64391   {
64392     try {
64393       if(darg) {
64394           (darg)->OnChildAddSwigPublic(*arg2);
64395       }
64396     } catch (std::out_of_range& e) {
64397       {
64398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64399       };
64400     } catch (std::exception& e) {
64401       {
64402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64403       };
64404     } catch (Dali::DaliException e) {
64405       {
64406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64407       };
64408     } catch (...) {
64409       {
64410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64411       };
64412     }
64413   }
64414
64415 }
64416
64417
64418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64420   Dali::Actor *arg2 = 0 ;
64421   SwigDirector_ViewImpl *darg = 0;
64422
64423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64424   arg2 = (Dali::Actor *)jarg2;
64425   if (!arg2) {
64426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64427     return ;
64428   }
64429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64430   if(!darg) {
64431     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64432     return;
64433   }
64434   {
64435     try {
64436       if(darg) {
64437         (darg)->OnChildRemove(*arg2);
64438       }
64439     } catch (std::out_of_range& e) {
64440       {
64441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64442       };
64443     } catch (std::exception& e) {
64444       {
64445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64446       };
64447     } catch (Dali::DaliException e) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64450       };
64451     } catch (...) {
64452       {
64453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64454       };
64455     }
64456   }
64457
64458 }
64459
64460
64461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64463   Dali::Actor *arg2 = 0 ;
64464   SwigDirector_ViewImpl *darg = 0;
64465
64466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64467   arg2 = (Dali::Actor *)jarg2;
64468   if (!arg2) {
64469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64470     return ;
64471   }
64472   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64473   if(!darg) {
64474     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64475     return;
64476   }
64477   {
64478     try {
64479       if(darg) {
64480         (darg)->OnChildRemoveSwigPublic(*arg2);
64481       }
64482     } catch (std::out_of_range& e) {
64483       {
64484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64485       };
64486     } catch (std::exception& e) {
64487       {
64488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64489       };
64490     } catch (Dali::DaliException e) {
64491       {
64492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64493       };
64494     } catch (...) {
64495       {
64496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64497       };
64498     }
64499   }
64500
64501 }
64502
64503
64504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64506   Dali::Property::Index arg2 ;
64507   Dali::Property::Value arg3 ;
64508   Dali::Property::Value *argp3 ;
64509   SwigDirector_ViewImpl *darg = 0;
64510
64511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64512   arg2 = (Dali::Property::Index)jarg2;
64513   argp3 = (Dali::Property::Value *)jarg3;
64514   if (!argp3) {
64515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64516     return ;
64517   }
64518   arg3 = *argp3;
64519   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64520   if (!darg) {
64521     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64522     return;
64523   }
64524   {
64525     try {
64526       (darg)->OnPropertySet(arg2,arg3);
64527     } catch (std::out_of_range& e) {
64528       {
64529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64530       };
64531     } catch (std::exception& e) {
64532       {
64533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64534       };
64535     } catch (Dali::DaliException e) {
64536       {
64537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64538       };
64539     } catch (...) {
64540       {
64541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64542       };
64543     }
64544   }
64545
64546 }
64547
64548
64549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64551   Dali::Property::Index arg2 ;
64552   Dali::Property::Value arg3 ;
64553   Dali::Property::Value *argp3 ;
64554   SwigDirector_ViewImpl *darg = 0;
64555
64556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64557   arg2 = (Dali::Property::Index)jarg2;
64558   argp3 = (Dali::Property::Value *)jarg3;
64559   if (!argp3) {
64560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64561     return ;
64562   }
64563   arg3 = *argp3;
64564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64565   if (!darg) {
64566     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64567     return;
64568   }
64569   {
64570     try {
64571       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64572     } catch (std::out_of_range& e) {
64573       {
64574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64575       };
64576     } catch (std::exception& e) {
64577       {
64578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64579       };
64580     } catch (Dali::DaliException e) {
64581       {
64582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64583       };
64584     } catch (...) {
64585       {
64586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64587       };
64588     }
64589   }
64590
64591 }
64592
64593
64594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64595   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64596   Dali::Vector3 *arg2 = 0 ;
64597   SwigDirector_ViewImpl *darg = 0;
64598
64599   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64600   arg2 = (Dali::Vector3 *)jarg2;
64601   if (!arg2) {
64602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64603     return ;
64604   }
64605   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64606   if (!darg) {
64607     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64608     return;
64609   }
64610   {
64611     try {
64612       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64613     } catch (std::out_of_range& e) {
64614       {
64615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64616       };
64617     } catch (std::exception& e) {
64618       {
64619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64620       };
64621     } catch (Dali::DaliException e) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64624       };
64625     } catch (...) {
64626       {
64627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64628       };
64629     }
64630   }
64631
64632 }
64633
64634
64635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64637   Dali::Vector3 *arg2 = 0 ;
64638   SwigDirector_ViewImpl *darg = 0;
64639
64640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64641   arg2 = (Dali::Vector3 *)jarg2;
64642   if (!arg2) {
64643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64644     return ;
64645   }
64646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64647   if (!darg) {
64648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64649     return;
64650   }
64651   {
64652     try {
64653       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64661       };
64662     } catch (Dali::DaliException e) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64669       };
64670     }
64671   }
64672
64673 }
64674
64675
64676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64678   Dali::Animation *arg2 = 0 ;
64679   Dali::Vector3 *arg3 = 0 ;
64680   SwigDirector_ViewImpl *darg = 0;
64681
64682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64683   arg2 = (Dali::Animation *)jarg2;
64684   if (!arg2) {
64685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64686     return ;
64687   }
64688   arg3 = (Dali::Vector3 *)jarg3;
64689   if (!arg3) {
64690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64691     return ;
64692   }
64693   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64694   if (!darg) {
64695     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64696     return;
64697   }
64698   {
64699     try {
64700       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64701     } catch (std::out_of_range& e) {
64702       {
64703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64704       };
64705     } catch (std::exception& e) {
64706       {
64707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64708       };
64709     } catch (Dali::DaliException e) {
64710       {
64711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64712       };
64713     } catch (...) {
64714       {
64715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64716       };
64717     }
64718   }
64719
64720 }
64721
64722
64723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64725   Dali::Animation *arg2 = 0 ;
64726   Dali::Vector3 *arg3 = 0 ;
64727   SwigDirector_ViewImpl *darg = 0;
64728
64729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64730   arg2 = (Dali::Animation *)jarg2;
64731   if (!arg2) {
64732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64733     return ;
64734   }
64735   arg3 = (Dali::Vector3 *)jarg3;
64736   if (!arg3) {
64737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64738     return ;
64739   }
64740   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64741   if (!darg) {
64742     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64743     return;
64744   }
64745   {
64746     try {
64747       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64748     } catch (std::out_of_range& e) {
64749       {
64750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64751       };
64752     } catch (std::exception& e) {
64753       {
64754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64755       };
64756     } catch (Dali::DaliException e) {
64757       {
64758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64759       };
64760     } catch (...) {
64761       {
64762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64763       };
64764     }
64765   }
64766
64767 }
64768
64769
64770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64771   unsigned int jresult ;
64772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64773   Dali::TouchEvent *arg2 = 0 ;
64774   SwigDirector_ViewImpl *darg = 0;
64775   bool result;
64776
64777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64778   arg2 = (Dali::TouchEvent *)jarg2;
64779   if (!arg2) {
64780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64781     return 0;
64782   }
64783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64784   if (!darg) {
64785     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64786     return 0;
64787   }
64788   {
64789     try {
64790       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64791     } catch (std::out_of_range& e) {
64792       {
64793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64794       };
64795     } catch (std::exception& e) {
64796       {
64797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64798       };
64799     } catch (Dali::DaliException e) {
64800       {
64801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64802       };
64803     } catch (...) {
64804       {
64805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64806       };
64807     }
64808   }
64809
64810   jresult = result;
64811   return jresult;
64812 }
64813
64814
64815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64816   unsigned int jresult ;
64817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64818   Dali::TouchEvent *arg2 = 0 ;
64819   SwigDirector_ViewImpl *darg = 0;
64820   bool result;
64821
64822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64823   arg2 = (Dali::TouchEvent *)jarg2;
64824   if (!arg2) {
64825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64826     return 0;
64827   }
64828   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64829   if (!darg) {
64830     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64831     return 0;
64832   }
64833   {
64834     try {
64835       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64836     } catch (std::out_of_range& e) {
64837       {
64838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64839       };
64840     } catch (std::exception& e) {
64841       {
64842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64843       };
64844     } catch (Dali::DaliException e) {
64845       {
64846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64847       };
64848     } catch (...) {
64849       {
64850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64851       };
64852     }
64853   }
64854
64855   jresult = result;
64856   return jresult;
64857 }
64858
64859
64860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64861   unsigned int jresult ;
64862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64863   Dali::HoverEvent *arg2 = 0 ;
64864   SwigDirector_ViewImpl *darg = 0;
64865   bool result;
64866
64867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64868   arg2 = (Dali::HoverEvent *)jarg2;
64869   if (!arg2) {
64870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64871     return 0;
64872   }
64873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64874   if (!darg) {
64875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64876     return 0;
64877   }
64878   {
64879     try {
64880       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64881     } catch (std::out_of_range& e) {
64882       {
64883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64884       };
64885     } catch (std::exception& e) {
64886       {
64887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64888       };
64889     } catch (Dali::DaliException e) {
64890       {
64891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64892       };
64893     } catch (...) {
64894       {
64895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64896       };
64897     }
64898   }
64899
64900   jresult = result;
64901   return jresult;
64902 }
64903
64904
64905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64906   unsigned int jresult ;
64907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64908   Dali::HoverEvent *arg2 = 0 ;
64909   SwigDirector_ViewImpl *darg = 0;
64910   bool result;
64911
64912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64913   arg2 = (Dali::HoverEvent *)jarg2;
64914   if (!arg2) {
64915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64916     return 0;
64917   }
64918   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64919   if (!darg) {
64920     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64921     return 0;
64922   }
64923   {
64924     try {
64925       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64926     } catch (std::out_of_range& e) {
64927       {
64928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64929       };
64930     } catch (std::exception& e) {
64931       {
64932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64933       };
64934     } catch (Dali::DaliException e) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64937       };
64938     } catch (...) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64941       };
64942     }
64943   }
64944
64945   jresult = result;
64946   return jresult;
64947 }
64948
64949
64950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64951   unsigned int jresult ;
64952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64953   Dali::KeyEvent *arg2 = 0 ;
64954   SwigDirector_ViewImpl *darg = 0;
64955   bool result;
64956
64957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64958   arg2 = (Dali::KeyEvent *)jarg2;
64959   if (!arg2) {
64960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64961     return 0;
64962   }
64963   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64964   if (!darg) {
64965     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64966     return 0;
64967   }
64968   {
64969     try {
64970       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64971     } catch (std::out_of_range& e) {
64972       {
64973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64974       };
64975     } catch (std::exception& e) {
64976       {
64977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64978       };
64979     } catch (Dali::DaliException e) {
64980       {
64981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64982       };
64983     } catch (...) {
64984       {
64985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64986       };
64987     }
64988   }
64989
64990   jresult = result;
64991   return jresult;
64992 }
64993
64994
64995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64996   unsigned int jresult ;
64997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64998   Dali::KeyEvent *arg2 = 0 ;
64999   SwigDirector_ViewImpl *darg = 0;
65000   bool result;
65001
65002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65003   arg2 = (Dali::KeyEvent *)jarg2;
65004   if (!arg2) {
65005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65006     return 0;
65007   }
65008   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65009   if (!darg) {
65010     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65011     return 0;
65012   }
65013   {
65014     try {
65015       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65023       };
65024     } catch (Dali::DaliException e) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65031       };
65032     }
65033   }
65034
65035   jresult = result;
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65041   unsigned int jresult ;
65042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65043   Dali::WheelEvent *arg2 = 0 ;
65044   SwigDirector_ViewImpl *darg = 0;
65045   bool result;
65046
65047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65048   arg2 = (Dali::WheelEvent *)jarg2;
65049   if (!arg2) {
65050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65051     return 0;
65052   }
65053   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65054   if (!darg) {
65055     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65056     return 0;
65057   }
65058   {
65059     try {
65060       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65061     } catch (std::out_of_range& e) {
65062       {
65063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65064       };
65065     } catch (std::exception& e) {
65066       {
65067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65068       };
65069     } catch (Dali::DaliException e) {
65070       {
65071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65072       };
65073     } catch (...) {
65074       {
65075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65076       };
65077     }
65078   }
65079
65080   jresult = result;
65081   return jresult;
65082 }
65083
65084
65085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65086   unsigned int jresult ;
65087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65088   Dali::WheelEvent *arg2 = 0 ;
65089   SwigDirector_ViewImpl *darg = 0;
65090   bool result;
65091
65092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65093   arg2 = (Dali::WheelEvent *)jarg2;
65094   if (!arg2) {
65095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65096     return 0;
65097   }
65098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65099   if (!darg) {
65100     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65101     return 0;
65102   }
65103   {
65104     try {
65105       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65106     } catch (std::out_of_range& e) {
65107       {
65108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (std::exception& e) {
65111       {
65112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (Dali::DaliException e) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65121       };
65122     }
65123   }
65124
65125   jresult = result;
65126   return jresult;
65127 }
65128
65129
65130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65131   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65132   Dali::Vector2 *arg2 = 0 ;
65133   Dali::RelayoutContainer *arg3 = 0 ;
65134   SwigDirector_ViewImpl *darg = 0;
65135
65136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65137   arg2 = (Dali::Vector2 *)jarg2;
65138   if (!arg2) {
65139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65140     return ;
65141   }
65142   arg3 = (Dali::RelayoutContainer *)jarg3;
65143   if (!arg3) {
65144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65145     return ;
65146   }
65147   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65148   if (!darg) {
65149     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65150     return;
65151   }
65152   {
65153     try {
65154       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65155     } catch (std::out_of_range& e) {
65156       {
65157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65158       };
65159     } catch (std::exception& e) {
65160       {
65161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65162       };
65163     } catch (Dali::DaliException e) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65170       };
65171     }
65172   }
65173
65174 }
65175
65176
65177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65179   Dali::Vector2 *arg2 = 0 ;
65180   Dali::RelayoutContainer *arg3 = 0 ;
65181   SwigDirector_ViewImpl *darg = 0;
65182
65183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65184   arg2 = (Dali::Vector2 *)jarg2;
65185   if (!arg2) {
65186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65187     return ;
65188   }
65189   arg3 = (Dali::RelayoutContainer *)jarg3;
65190   if (!arg3) {
65191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65192     return ;
65193   }
65194   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65195   if (!darg) {
65196     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65197     return;
65198   }
65199   {
65200     try {
65201       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65202     } catch (std::out_of_range& e) {
65203       {
65204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65205       };
65206     } catch (std::exception& e) {
65207       {
65208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65209       };
65210     } catch (Dali::DaliException e) {
65211       {
65212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65213       };
65214     } catch (...) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65217       };
65218     }
65219   }
65220
65221 }
65222
65223
65224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65226   Dali::ResizePolicy::Type arg2 ;
65227   Dali::Dimension::Type arg3 ;
65228   SwigDirector_ViewImpl *darg = 0;
65229
65230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65231   arg2 = (Dali::ResizePolicy::Type)jarg2;
65232   arg3 = (Dali::Dimension::Type)jarg3;
65233   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65234   if (!darg) {
65235     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65236     return;
65237   }
65238   {
65239     try {
65240       (darg)->OnSetResizePolicy(arg2,arg3);
65241     } catch (std::out_of_range& e) {
65242       {
65243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65244       };
65245     } catch (std::exception& e) {
65246       {
65247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65248       };
65249     } catch (Dali::DaliException e) {
65250       {
65251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65252       };
65253     } catch (...) {
65254       {
65255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65256       };
65257     }
65258   }
65259
65260 }
65261
65262
65263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65265   Dali::ResizePolicy::Type arg2 ;
65266   Dali::Dimension::Type arg3 ;
65267   SwigDirector_ViewImpl *darg = 0;
65268
65269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65270   arg2 = (Dali::ResizePolicy::Type)jarg2;
65271   arg3 = (Dali::Dimension::Type)jarg3;
65272   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65273   if (!darg) {
65274     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65275     return;
65276   }
65277   {
65278     try {
65279       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65280     } catch (std::out_of_range& e) {
65281       {
65282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65283       };
65284     } catch (std::exception& e) {
65285       {
65286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65287       };
65288     } catch (Dali::DaliException e) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65291       };
65292     } catch (...) {
65293       {
65294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65295       };
65296     }
65297   }
65298
65299 }
65300
65301
65302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65303   void * jresult ;
65304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65305   SwigDirector_ViewImpl *darg = 0;
65306   Dali::Vector3 result;
65307
65308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65309   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65310   if (!darg) {
65311     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65312     return 0;
65313   }
65314   {
65315     try {
65316       result = (darg)->GetNaturalSize();
65317     } catch (std::out_of_range& e) {
65318       {
65319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65320       };
65321     } catch (std::exception& e) {
65322       {
65323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65324       };
65325     } catch (Dali::DaliException e) {
65326       {
65327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65328       };
65329     } catch (...) {
65330       {
65331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65332       };
65333     }
65334   }
65335
65336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65337   return jresult;
65338 }
65339
65340
65341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65342   void * jresult ;
65343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65344   SwigDirector_ViewImpl *darg = 0;
65345   Dali::Vector3 result;
65346
65347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65348   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65349   if (!darg) {
65350     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65351     return 0;
65352   }
65353   {
65354     try {
65355       result = (darg)->GetNaturalSizeSwigPublic();
65356     } catch (std::out_of_range& e) {
65357       {
65358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65359       };
65360     } catch (std::exception& e) {
65361       {
65362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65363       };
65364     } catch (Dali::DaliException e) {
65365       {
65366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65367       };
65368     } catch (...) {
65369       {
65370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65371       };
65372     }
65373   }
65374
65375   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65376   return jresult;
65377 }
65378
65379
65380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65381   float jresult ;
65382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65383   Dali::Actor *arg2 = 0 ;
65384   Dali::Dimension::Type arg3 ;
65385   SwigDirector_ViewImpl *darg = 0;
65386   float result;
65387
65388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65389   arg2 = (Dali::Actor *)jarg2;
65390   if (!arg2) {
65391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65392     return 0;
65393   }
65394   arg3 = (Dali::Dimension::Type)jarg3;
65395   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65396   if (!darg) {
65397     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65398     return 0;
65399   }
65400   {
65401     try {
65402       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65403     } catch (std::out_of_range& e) {
65404       {
65405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (std::exception& e) {
65408       {
65409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65410       };
65411     } catch (Dali::DaliException e) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65418       };
65419     }
65420   }
65421
65422   jresult = result;
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65428   float jresult ;
65429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65430   Dali::Actor *arg2 = 0 ;
65431   Dali::Dimension::Type arg3 ;
65432   SwigDirector_ViewImpl *darg = 0;
65433   float result;
65434
65435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65436   arg2 = (Dali::Actor *)jarg2;
65437   if (!arg2) {
65438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65439     return 0;
65440   }
65441   arg3 = (Dali::Dimension::Type)jarg3;
65442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65443   if (!darg) {
65444     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65445     return 0;
65446   }
65447   {
65448     try {
65449       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65450     } catch (std::out_of_range& e) {
65451       {
65452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65453       };
65454     } catch (std::exception& e) {
65455       {
65456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65457       };
65458     } catch (Dali::DaliException e) {
65459       {
65460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65461       };
65462     } catch (...) {
65463       {
65464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65465       };
65466     }
65467   }
65468
65469   jresult = result;
65470   return jresult;
65471 }
65472
65473
65474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65475   float jresult ;
65476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65477   float arg2 ;
65478   SwigDirector_ViewImpl *darg = 0;
65479   float result;
65480
65481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65482   arg2 = (float)jarg2;
65483   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65484   if (!darg) {
65485     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65486     return 0;
65487   }
65488   {
65489     try {
65490       result = (float)(darg)->GetHeightForWidth(arg2);
65491     } catch (std::out_of_range& e) {
65492       {
65493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65494       };
65495     } catch (std::exception& e) {
65496       {
65497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65498       };
65499     } catch (Dali::DaliException e) {
65500       {
65501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65502       };
65503     } catch (...) {
65504       {
65505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65506       };
65507     }
65508   }
65509
65510   jresult = result;
65511   return jresult;
65512 }
65513
65514
65515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65516   float jresult ;
65517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65518   float arg2 ;
65519   SwigDirector_ViewImpl *darg = 0;
65520   float result;
65521
65522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65523   arg2 = (float)jarg2;
65524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65525   if (!darg) {
65526     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65527     return 0;
65528   }
65529   {
65530     try {
65531       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65532     } catch (std::out_of_range& e) {
65533       {
65534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65535       };
65536     } catch (std::exception& e) {
65537       {
65538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65539       };
65540     } catch (Dali::DaliException e) {
65541       {
65542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65543       };
65544     } catch (...) {
65545       {
65546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65547       };
65548     }
65549   }
65550
65551   jresult = result;
65552   return jresult;
65553 }
65554
65555
65556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65557   float jresult ;
65558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65559   float arg2 ;
65560   SwigDirector_ViewImpl *darg = 0;
65561   float result;
65562
65563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65564   arg2 = (float)jarg2;
65565   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65566   if (!darg) {
65567     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65568     return 0;
65569   }
65570   {
65571     try {
65572       result = (float)(darg)->GetWidthForHeight(arg2);
65573     } catch (std::out_of_range& e) {
65574       {
65575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65576       };
65577     } catch (std::exception& e) {
65578       {
65579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (Dali::DaliException e) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65588       };
65589     }
65590   }
65591
65592   jresult = result;
65593   return jresult;
65594 }
65595
65596
65597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65598   float jresult ;
65599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65600   float arg2 ;
65601   SwigDirector_ViewImpl *darg = 0;
65602   float result;
65603
65604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65605   arg2 = (float)jarg2;
65606   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65607   if (!darg) {
65608     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65609     return 0;
65610   }
65611   {
65612     try {
65613       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65614     } catch (std::out_of_range& e) {
65615       {
65616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65617       };
65618     } catch (std::exception& e) {
65619       {
65620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65621       };
65622     } catch (Dali::DaliException e) {
65623       {
65624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65625       };
65626     } catch (...) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65629       };
65630     }
65631   }
65632
65633   jresult = result;
65634   return jresult;
65635 }
65636
65637
65638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65639   unsigned int jresult ;
65640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65641   Dali::Dimension::Type arg2 ;
65642   SwigDirector_ViewImpl *darg = 0;
65643   bool result;
65644
65645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65646   arg2 = (Dali::Dimension::Type)jarg2;
65647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65648   if (!darg) {
65649     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65650     return 0;
65651   }
65652   {
65653     try {
65654       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (Dali::DaliException e) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673
65674   jresult = result;
65675   return jresult;
65676 }
65677
65678
65679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65680   unsigned int jresult ;
65681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65682   Dali::Dimension::Type arg2 ;
65683   SwigDirector_ViewImpl *darg = 0;
65684   bool result;
65685
65686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65687   arg2 = (Dali::Dimension::Type)jarg2;
65688   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65689   if (!darg) {
65690     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65691     return 0;
65692   }
65693   {
65694     try {
65695       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65696     } catch (std::out_of_range& e) {
65697       {
65698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65699       };
65700     } catch (std::exception& e) {
65701       {
65702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65703       };
65704     } catch (Dali::DaliException e) {
65705       {
65706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65707       };
65708     } catch (...) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65711       };
65712     }
65713   }
65714
65715   jresult = result;
65716   return jresult;
65717 }
65718
65719
65720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65721   unsigned int jresult ;
65722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65723   SwigDirector_ViewImpl *darg = 0;
65724   bool result;
65725
65726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65727   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65728   if (!darg) {
65729     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65730     return 0;
65731   }
65732   {
65733     try {
65734       result = (bool)(darg)->RelayoutDependentOnChildren();
65735     } catch (std::out_of_range& e) {
65736       {
65737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65738       };
65739     } catch (std::exception& e) {
65740       {
65741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65742       };
65743     } catch (Dali::DaliException e) {
65744       {
65745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65746       };
65747     } catch (...) {
65748       {
65749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65750       };
65751     }
65752   }
65753
65754   jresult = result;
65755   return jresult;
65756 }
65757
65758
65759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65760   unsigned int jresult ;
65761   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65762   SwigDirector_ViewImpl *darg = 0;
65763   bool result;
65764
65765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65766   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65767   if (!darg) {
65768     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65769     return 0;
65770   }
65771   {
65772     try {
65773       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65774     } catch (std::out_of_range& e) {
65775       {
65776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65777       };
65778     } catch (std::exception& e) {
65779       {
65780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65781       };
65782     } catch (Dali::DaliException e) {
65783       {
65784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65785       };
65786     } catch (...) {
65787       {
65788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65789       };
65790     }
65791   }
65792
65793   jresult = result;
65794   return jresult;
65795 }
65796
65797
65798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65800   Dali::Dimension::Type arg2 ;
65801   SwigDirector_ViewImpl *darg = 0;
65802
65803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65804   arg2 = (Dali::Dimension::Type)jarg2;
65805   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65806   if (!darg) {
65807     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65808     return;
65809   }
65810   {
65811     try {
65812       (darg)->OnCalculateRelayoutSize(arg2);
65813     } catch (std::out_of_range& e) {
65814       {
65815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65816       };
65817     } catch (std::exception& e) {
65818       {
65819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65820       };
65821     } catch (Dali::DaliException e) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65824       };
65825     } catch (...) {
65826       {
65827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65828       };
65829     }
65830   }
65831
65832 }
65833
65834
65835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65837   Dali::Dimension::Type arg2 ;
65838   SwigDirector_ViewImpl *darg = 0;
65839
65840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65841   arg2 = (Dali::Dimension::Type)jarg2;
65842   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65843   if (!darg) {
65844     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65845     return;
65846   }
65847   {
65848     try {
65849       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65850     } catch (std::out_of_range& e) {
65851       {
65852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65853       };
65854     } catch (std::exception& e) {
65855       {
65856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65857       };
65858     } catch (Dali::DaliException e) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65861       };
65862     } catch (...) {
65863       {
65864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65865       };
65866     }
65867   }
65868
65869 }
65870
65871
65872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65874   float arg2 ;
65875   Dali::Dimension::Type arg3 ;
65876   SwigDirector_ViewImpl *darg = 0;
65877
65878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65879   arg2 = (float)jarg2;
65880   arg3 = (Dali::Dimension::Type)jarg3;
65881   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65882   if (!darg) {
65883     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65884     return;
65885   }
65886   {
65887     try {
65888       (darg)->OnLayoutNegotiated(arg2,arg3);
65889     } catch (std::out_of_range& e) {
65890       {
65891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65892       };
65893     } catch (std::exception& e) {
65894       {
65895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65896       };
65897     } catch (Dali::DaliException e) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65900       };
65901     } catch (...) {
65902       {
65903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65904       };
65905     }
65906   }
65907
65908 }
65909
65910
65911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65913   float arg2 ;
65914   Dali::Dimension::Type arg3 ;
65915   SwigDirector_ViewImpl *darg = 0;
65916
65917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65918   arg2 = (float)jarg2;
65919   arg3 = (Dali::Dimension::Type)jarg3;
65920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65921   if (!darg) {
65922     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65923     return;
65924   }
65925   {
65926     try {
65927       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65928     } catch (std::out_of_range& e) {
65929       {
65930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65931       };
65932     } catch (std::exception& e) {
65933       {
65934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65935       };
65936     } catch (Dali::DaliException e) {
65937       {
65938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65939       };
65940     } catch (...) {
65941       {
65942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65943       };
65944     }
65945   }
65946
65947 }
65948
65949
65950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65952
65953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65954   {
65955     try {
65956       (arg1)->OnInitialize();
65957     } catch (std::out_of_range& e) {
65958       {
65959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65960       };
65961     } catch (std::exception& e) {
65962       {
65963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65964       };
65965     } catch (Dali::DaliException e) {
65966       {
65967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65968       };
65969     } catch (...) {
65970       {
65971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65972       };
65973     }
65974   }
65975
65976 }
65977
65978
65979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65981
65982   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65983   {
65984     try {
65985       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65986     } catch (std::out_of_range& e) {
65987       {
65988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65989       };
65990     } catch (std::exception& e) {
65991       {
65992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65993       };
65994     } catch (Dali::DaliException e) {
65995       {
65996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65997       };
65998     } catch (...) {
65999       {
66000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66001       };
66002     }
66003   }
66004
66005 }
66006
66007
66008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66010   Dali::Actor *arg2 = 0 ;
66011
66012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66013   arg2 = (Dali::Actor *)jarg2;
66014   if (!arg2) {
66015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66016     return ;
66017   }
66018   {
66019     try {
66020       (arg1)->OnControlChildAdd(*arg2);
66021     } catch (std::out_of_range& e) {
66022       {
66023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66024       };
66025     } catch (std::exception& e) {
66026       {
66027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66028       };
66029     } catch (Dali::DaliException e) {
66030       {
66031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66032       };
66033     } catch (...) {
66034       {
66035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66036       };
66037     }
66038   }
66039
66040 }
66041
66042
66043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66044   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66045   Dali::Actor *arg2 = 0 ;
66046
66047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66048   arg2 = (Dali::Actor *)jarg2;
66049   if (!arg2) {
66050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66051     return ;
66052   }
66053   {
66054     try {
66055       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66056     } catch (std::out_of_range& e) {
66057       {
66058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66059       };
66060     } catch (std::exception& e) {
66061       {
66062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66063       };
66064     } catch (Dali::DaliException e) {
66065       {
66066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66067       };
66068     } catch (...) {
66069       {
66070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66071       };
66072     }
66073   }
66074
66075 }
66076
66077
66078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66080   Dali::Actor *arg2 = 0 ;
66081
66082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66083   arg2 = (Dali::Actor *)jarg2;
66084   if (!arg2) {
66085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66086     return ;
66087   }
66088   {
66089     try {
66090       (arg1)->OnControlChildRemove(*arg2);
66091     } catch (std::out_of_range& e) {
66092       {
66093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66094       };
66095     } catch (std::exception& e) {
66096       {
66097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66098       };
66099     } catch (Dali::DaliException e) {
66100       {
66101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66102       };
66103     } catch (...) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66106       };
66107     }
66108   }
66109
66110 }
66111
66112
66113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66115   Dali::Actor *arg2 = 0 ;
66116
66117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66118   arg2 = (Dali::Actor *)jarg2;
66119   if (!arg2) {
66120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66121     return ;
66122   }
66123   {
66124     try {
66125       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66126     } catch (std::out_of_range& e) {
66127       {
66128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66129       };
66130     } catch (std::exception& e) {
66131       {
66132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66133       };
66134     } catch (Dali::DaliException e) {
66135       {
66136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66137       };
66138     } catch (...) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66141       };
66142     }
66143   }
66144
66145 }
66146
66147
66148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66150   Dali::Toolkit::StyleManager arg2 ;
66151   Dali::StyleChange::Type arg3 ;
66152   Dali::Toolkit::StyleManager *argp2 ;
66153
66154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66155   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66156   if (!argp2) {
66157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66158     return ;
66159   }
66160   arg2 = *argp2;
66161   arg3 = (Dali::StyleChange::Type)jarg3;
66162   {
66163     try {
66164       (arg1)->OnStyleChange(arg2,arg3);
66165     } catch (std::out_of_range& e) {
66166       {
66167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66168       };
66169     } catch (std::exception& e) {
66170       {
66171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66172       };
66173     } catch (Dali::DaliException e) {
66174       {
66175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66176       };
66177     } catch (...) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66180       };
66181     }
66182   }
66183
66184 }
66185
66186
66187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66189   Dali::Toolkit::StyleManager arg2 ;
66190   Dali::StyleChange::Type arg3 ;
66191   Dali::Toolkit::StyleManager *argp2 ;
66192
66193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66194   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66195   if (!argp2) {
66196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66197     return ;
66198   }
66199   arg2 = *argp2;
66200   arg3 = (Dali::StyleChange::Type)jarg3;
66201   {
66202     try {
66203       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66204     } catch (std::out_of_range& e) {
66205       {
66206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66207       };
66208     } catch (std::exception& e) {
66209       {
66210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66211       };
66212     } catch (Dali::DaliException e) {
66213       {
66214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66215       };
66216     } catch (...) {
66217       {
66218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66219       };
66220     }
66221   }
66222
66223 }
66224
66225
66226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66227   unsigned int jresult ;
66228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66229   bool result;
66230
66231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66232   {
66233     try {
66234       result = (bool)(arg1)->OnAccessibilityActivated();
66235     } catch (std::out_of_range& e) {
66236       {
66237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66238       };
66239     } catch (std::exception& e) {
66240       {
66241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66242       };
66243     } catch (Dali::DaliException e) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66250       };
66251     }
66252   }
66253
66254   jresult = result;
66255   return jresult;
66256 }
66257
66258
66259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66260   unsigned int jresult ;
66261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66262   bool result;
66263
66264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66265   {
66266     try {
66267       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66268     } catch (std::out_of_range& e) {
66269       {
66270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66271       };
66272     } catch (std::exception& e) {
66273       {
66274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66275       };
66276     } catch (Dali::DaliException e) {
66277       {
66278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66279       };
66280     } catch (...) {
66281       {
66282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66283       };
66284     }
66285   }
66286
66287   jresult = result;
66288   return jresult;
66289 }
66290
66291
66292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66293   unsigned int jresult ;
66294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66295   Dali::PanGesture arg2 ;
66296   Dali::PanGesture *argp2 ;
66297   bool result;
66298
66299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66300   argp2 = (Dali::PanGesture *)jarg2;
66301   if (!argp2) {
66302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66303     return 0;
66304   }
66305   arg2 = *argp2;
66306   {
66307     try {
66308       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66309     } catch (std::out_of_range& e) {
66310       {
66311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66312       };
66313     } catch (std::exception& e) {
66314       {
66315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66316       };
66317     } catch (Dali::DaliException e) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66320       };
66321     } catch (...) {
66322       {
66323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66324       };
66325     }
66326   }
66327
66328   jresult = result;
66329   return jresult;
66330 }
66331
66332
66333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66334   unsigned int jresult ;
66335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66336   Dali::PanGesture arg2 ;
66337   Dali::PanGesture *argp2 ;
66338   bool result;
66339
66340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66341   argp2 = (Dali::PanGesture *)jarg2;
66342   if (!argp2) {
66343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66344     return 0;
66345   }
66346   arg2 = *argp2;
66347   {
66348     try {
66349       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66350     } catch (std::out_of_range& e) {
66351       {
66352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66353       };
66354     } catch (std::exception& e) {
66355       {
66356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66357       };
66358     } catch (Dali::DaliException e) {
66359       {
66360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66361       };
66362     } catch (...) {
66363       {
66364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66365       };
66366     }
66367   }
66368
66369   jresult = result;
66370   return jresult;
66371 }
66372
66373
66374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66375   unsigned int jresult ;
66376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66377   Dali::TouchEvent *arg2 = 0 ;
66378   bool result;
66379
66380   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66381   arg2 = (Dali::TouchEvent *)jarg2;
66382   if (!arg2) {
66383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66384     return 0;
66385   }
66386   {
66387     try {
66388       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66389     } catch (std::out_of_range& e) {
66390       {
66391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66392       };
66393     } catch (std::exception& e) {
66394       {
66395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66396       };
66397     } catch (Dali::DaliException e) {
66398       {
66399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66404       };
66405     }
66406   }
66407
66408   jresult = result;
66409   return jresult;
66410 }
66411
66412
66413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66414   unsigned int jresult ;
66415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66416   Dali::TouchEvent *arg2 = 0 ;
66417   bool result;
66418
66419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66420   arg2 = (Dali::TouchEvent *)jarg2;
66421   if (!arg2) {
66422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66423     return 0;
66424   }
66425   {
66426     try {
66427       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66428     } catch (std::out_of_range& e) {
66429       {
66430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66431       };
66432     } catch (std::exception& e) {
66433       {
66434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66435       };
66436     } catch (Dali::DaliException e) {
66437       {
66438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66439       };
66440     } catch (...) {
66441       {
66442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66443       };
66444     }
66445   }
66446
66447   jresult = result;
66448   return jresult;
66449 }
66450
66451
66452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66453   unsigned int jresult ;
66454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66455   bool arg2 ;
66456   bool result;
66457
66458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66459   arg2 = jarg2 ? true : false;
66460   {
66461     try {
66462       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66463     } catch (std::out_of_range& e) {
66464       {
66465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66466       };
66467     } catch (std::exception& e) {
66468       {
66469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66470       };
66471     } catch (Dali::DaliException e) {
66472       {
66473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66474       };
66475     } catch (...) {
66476       {
66477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66478       };
66479     }
66480   }
66481
66482   jresult = result;
66483   return jresult;
66484 }
66485
66486
66487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66488   unsigned int jresult ;
66489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66490   bool arg2 ;
66491   bool result;
66492
66493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66494   arg2 = jarg2 ? true : false;
66495   {
66496     try {
66497       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66498     } catch (std::out_of_range& e) {
66499       {
66500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66501       };
66502     } catch (std::exception& e) {
66503       {
66504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66505       };
66506     } catch (Dali::DaliException e) {
66507       {
66508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66509       };
66510     } catch (...) {
66511       {
66512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66513       };
66514     }
66515   }
66516
66517   jresult = result;
66518   return jresult;
66519 }
66520
66521
66522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66523   unsigned int jresult ;
66524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66525   bool result;
66526
66527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66528   {
66529     try {
66530       result = (bool)(arg1)->OnAccessibilityZoom();
66531     } catch (std::out_of_range& e) {
66532       {
66533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66534       };
66535     } catch (std::exception& e) {
66536       {
66537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66538       };
66539     } catch (Dali::DaliException e) {
66540       {
66541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66542       };
66543     } catch (...) {
66544       {
66545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66546       };
66547     }
66548   }
66549
66550   jresult = result;
66551   return jresult;
66552 }
66553
66554
66555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66556   unsigned int jresult ;
66557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66558   bool result;
66559
66560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66561   {
66562     try {
66563       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66564     } catch (std::out_of_range& e) {
66565       {
66566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66567       };
66568     } catch (std::exception& e) {
66569       {
66570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66571       };
66572     } catch (Dali::DaliException e) {
66573       {
66574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66575       };
66576     } catch (...) {
66577       {
66578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66579       };
66580     }
66581   }
66582
66583   jresult = result;
66584   return jresult;
66585 }
66586
66587
66588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66590
66591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66592   {
66593     try {
66594       (arg1)->OnKeyInputFocusGained();
66595     } catch (std::out_of_range& e) {
66596       {
66597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66598       };
66599     } catch (std::exception& e) {
66600       {
66601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66602       };
66603     } catch (Dali::DaliException e) {
66604       {
66605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66606       };
66607     } catch (...) {
66608       {
66609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66610       };
66611     }
66612   }
66613
66614 }
66615
66616
66617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66619
66620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66621   {
66622     try {
66623       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66624     } catch (std::out_of_range& e) {
66625       {
66626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66627       };
66628     } catch (std::exception& e) {
66629       {
66630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66631       };
66632     } catch (Dali::DaliException e) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66639       };
66640     }
66641   }
66642
66643 }
66644
66645
66646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66648
66649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66650   {
66651     try {
66652       (arg1)->OnKeyInputFocusLost();
66653     } catch (std::out_of_range& e) {
66654       {
66655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66656       };
66657     } catch (std::exception& e) {
66658       {
66659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66660       };
66661     } catch (Dali::DaliException e) {
66662       {
66663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66664       };
66665     } catch (...) {
66666       {
66667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66668       };
66669     }
66670   }
66671
66672 }
66673
66674
66675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66677
66678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66679   {
66680     try {
66681       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66682     } catch (std::out_of_range& e) {
66683       {
66684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66685       };
66686     } catch (std::exception& e) {
66687       {
66688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66689       };
66690     } catch (Dali::DaliException e) {
66691       {
66692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66693       };
66694     } catch (...) {
66695       {
66696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66697       };
66698     }
66699   }
66700
66701 }
66702
66703
66704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66705   void * jresult ;
66706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66707   Dali::Actor arg2 ;
66708   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66709   bool arg4 ;
66710   Dali::Actor *argp2 ;
66711   Dali::Actor result;
66712
66713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66714   argp2 = (Dali::Actor *)jarg2;
66715   if (!argp2) {
66716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66717     return 0;
66718   }
66719   arg2 = *argp2;
66720   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66721   arg4 = jarg4 ? true : false;
66722   {
66723     try {
66724       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66725     } catch (std::out_of_range& e) {
66726       {
66727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66728       };
66729     } catch (std::exception& e) {
66730       {
66731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66732       };
66733     } catch (Dali::DaliException e) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66736       };
66737     } catch (...) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66740       };
66741     }
66742   }
66743
66744   jresult = new Dali::Actor((const Dali::Actor &)result);
66745   return jresult;
66746 }
66747
66748
66749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66750   void * jresult ;
66751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66752   Dali::Actor arg2 ;
66753   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66754   bool arg4 ;
66755   Dali::Actor *argp2 ;
66756   Dali::Actor result;
66757
66758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66759   argp2 = (Dali::Actor *)jarg2;
66760   if (!argp2) {
66761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66762     return 0;
66763   }
66764   arg2 = *argp2;
66765   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66766   arg4 = jarg4 ? true : false;
66767   {
66768     try {
66769       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66770     } catch (std::out_of_range& e) {
66771       {
66772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66773       };
66774     } catch (std::exception& e) {
66775       {
66776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66777       };
66778     } catch (Dali::DaliException e) {
66779       {
66780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66781       };
66782     } catch (...) {
66783       {
66784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66785       };
66786     }
66787   }
66788
66789   jresult = new Dali::Actor((const Dali::Actor &)result);
66790   return jresult;
66791 }
66792
66793
66794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66796   Dali::Actor arg2 ;
66797   Dali::Actor *argp2 ;
66798
66799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66800   argp2 = (Dali::Actor *)jarg2;
66801   if (!argp2) {
66802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66803     return ;
66804   }
66805   arg2 = *argp2;
66806   {
66807     try {
66808       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66809     } catch (std::out_of_range& e) {
66810       {
66811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66812       };
66813     } catch (std::exception& e) {
66814       {
66815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66816       };
66817     } catch (Dali::DaliException e) {
66818       {
66819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66820       };
66821     } catch (...) {
66822       {
66823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66824       };
66825     }
66826   }
66827
66828 }
66829
66830
66831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66833   Dali::Actor arg2 ;
66834   Dali::Actor *argp2 ;
66835
66836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66837   argp2 = (Dali::Actor *)jarg2;
66838   if (!argp2) {
66839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66840     return ;
66841   }
66842   arg2 = *argp2;
66843   {
66844     try {
66845       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66846     } catch (std::out_of_range& e) {
66847       {
66848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66849       };
66850     } catch (std::exception& e) {
66851       {
66852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66853       };
66854     } catch (Dali::DaliException e) {
66855       {
66856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66857       };
66858     } catch (...) {
66859       {
66860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66861       };
66862     }
66863   }
66864
66865 }
66866
66867
66868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66869   unsigned int jresult ;
66870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66871   bool result;
66872
66873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66874   {
66875     try {
66876       result = (bool)(arg1)->OnKeyboardEnter();
66877     } catch (std::out_of_range& e) {
66878       {
66879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66880       };
66881     } catch (std::exception& e) {
66882       {
66883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66884       };
66885     } catch (Dali::DaliException e) {
66886       {
66887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66888       };
66889     } catch (...) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66892       };
66893     }
66894   }
66895
66896   jresult = result;
66897   return jresult;
66898 }
66899
66900
66901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66902   unsigned int jresult ;
66903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66904   bool result;
66905
66906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66907   {
66908     try {
66909       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66910     } catch (std::out_of_range& e) {
66911       {
66912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66913       };
66914     } catch (std::exception& e) {
66915       {
66916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66917       };
66918     } catch (Dali::DaliException e) {
66919       {
66920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66921       };
66922     } catch (...) {
66923       {
66924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66925       };
66926     }
66927   }
66928
66929   jresult = result;
66930   return jresult;
66931 }
66932
66933
66934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66936   Dali::PinchGesture *arg2 = 0 ;
66937
66938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66939   arg2 = (Dali::PinchGesture *)jarg2;
66940   if (!arg2) {
66941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66942     return ;
66943   }
66944   {
66945     try {
66946       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66947     } catch (std::out_of_range& e) {
66948       {
66949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66950       };
66951     } catch (std::exception& e) {
66952       {
66953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66954       };
66955     } catch (Dali::DaliException e) {
66956       {
66957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66958       };
66959     } catch (...) {
66960       {
66961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66962       };
66963     }
66964   }
66965
66966 }
66967
66968
66969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66971   Dali::PinchGesture *arg2 = 0 ;
66972
66973   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66974   arg2 = (Dali::PinchGesture *)jarg2;
66975   if (!arg2) {
66976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66977     return ;
66978   }
66979   {
66980     try {
66981       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66982     } catch (std::out_of_range& e) {
66983       {
66984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66985       };
66986     } catch (std::exception& e) {
66987       {
66988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66989       };
66990     } catch (Dali::DaliException e) {
66991       {
66992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66993       };
66994     } catch (...) {
66995       {
66996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66997       };
66998     }
66999   }
67000
67001 }
67002
67003
67004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67006   Dali::PanGesture *arg2 = 0 ;
67007
67008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67009   arg2 = (Dali::PanGesture *)jarg2;
67010   if (!arg2) {
67011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67012     return ;
67013   }
67014   {
67015     try {
67016       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67017     } catch (std::out_of_range& e) {
67018       {
67019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67020       };
67021     } catch (std::exception& e) {
67022       {
67023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67024       };
67025     } catch (Dali::DaliException e) {
67026       {
67027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67028       };
67029     } catch (...) {
67030       {
67031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67032       };
67033     }
67034   }
67035
67036 }
67037
67038
67039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67040   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67041   Dali::PanGesture *arg2 = 0 ;
67042
67043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67044   arg2 = (Dali::PanGesture *)jarg2;
67045   if (!arg2) {
67046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67047     return ;
67048   }
67049   {
67050     try {
67051       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67052     } catch (std::out_of_range& e) {
67053       {
67054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67055       };
67056     } catch (std::exception& e) {
67057       {
67058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67059       };
67060     } catch (Dali::DaliException e) {
67061       {
67062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67063       };
67064     } catch (...) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67067       };
67068     }
67069   }
67070
67071 }
67072
67073
67074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67076   Dali::TapGesture *arg2 = 0 ;
67077
67078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67079   arg2 = (Dali::TapGesture *)jarg2;
67080   if (!arg2) {
67081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67082     return ;
67083   }
67084   {
67085     try {
67086       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67087     } catch (std::out_of_range& e) {
67088       {
67089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67090       };
67091     } catch (std::exception& e) {
67092       {
67093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (Dali::DaliException e) {
67096       {
67097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67098       };
67099     } catch (...) {
67100       {
67101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67102       };
67103     }
67104   }
67105
67106 }
67107
67108
67109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67111   Dali::TapGesture *arg2 = 0 ;
67112
67113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67114   arg2 = (Dali::TapGesture *)jarg2;
67115   if (!arg2) {
67116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67117     return ;
67118   }
67119   {
67120     try {
67121       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67122     } catch (std::out_of_range& e) {
67123       {
67124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67125       };
67126     } catch (std::exception& e) {
67127       {
67128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67129       };
67130     } catch (Dali::DaliException e) {
67131       {
67132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67133       };
67134     } catch (...) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67137       };
67138     }
67139   }
67140
67141 }
67142
67143
67144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67146   Dali::LongPressGesture *arg2 = 0 ;
67147
67148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67149   arg2 = (Dali::LongPressGesture *)jarg2;
67150   if (!arg2) {
67151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67152     return ;
67153   }
67154   {
67155     try {
67156       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67157     } catch (std::out_of_range& e) {
67158       {
67159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67160       };
67161     } catch (std::exception& e) {
67162       {
67163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67164       };
67165     } catch (Dali::DaliException e) {
67166       {
67167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67168       };
67169     } catch (...) {
67170       {
67171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67172       };
67173     }
67174   }
67175
67176 }
67177
67178
67179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67181   Dali::LongPressGesture *arg2 = 0 ;
67182
67183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67184   arg2 = (Dali::LongPressGesture *)jarg2;
67185   if (!arg2) {
67186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67187     return ;
67188   }
67189   {
67190     try {
67191       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67192     } catch (std::out_of_range& e) {
67193       {
67194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67195       };
67196     } catch (std::exception& e) {
67197       {
67198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67199       };
67200     } catch (Dali::DaliException e) {
67201       {
67202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67203       };
67204     } catch (...) {
67205       {
67206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67207       };
67208     }
67209   }
67210
67211 }
67212
67213
67214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67216   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67217   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67218
67219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67220   arg2 = (Dali::SlotObserver *)jarg2;
67221   arg3 = (Dali::CallbackBase *)jarg3;
67222   {
67223     try {
67224       (arg1)->SignalConnected(arg2,arg3);
67225     } catch (std::out_of_range& e) {
67226       {
67227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67228       };
67229     } catch (std::exception& e) {
67230       {
67231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67232       };
67233     } catch (Dali::DaliException e) {
67234       {
67235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67236       };
67237     } catch (...) {
67238       {
67239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67240       };
67241     }
67242   }
67243
67244 }
67245
67246
67247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67249   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67250   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67251
67252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67253   arg2 = (Dali::SlotObserver *)jarg2;
67254   arg3 = (Dali::CallbackBase *)jarg3;
67255   {
67256     try {
67257       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67258     } catch (std::out_of_range& e) {
67259       {
67260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67261       };
67262     } catch (std::exception& e) {
67263       {
67264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67265       };
67266     } catch (Dali::DaliException e) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67269       };
67270     } catch (...) {
67271       {
67272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67273       };
67274     }
67275   }
67276
67277 }
67278
67279
67280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67282   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67283   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67284
67285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67286   arg2 = (Dali::SlotObserver *)jarg2;
67287   arg3 = (Dali::CallbackBase *)jarg3;
67288   {
67289     try {
67290       (arg1)->SignalDisconnected(arg2,arg3);
67291     } catch (std::out_of_range& e) {
67292       {
67293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67294       };
67295     } catch (std::exception& e) {
67296       {
67297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67298       };
67299     } catch (Dali::DaliException e) {
67300       {
67301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67302       };
67303     } catch (...) {
67304       {
67305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67306       };
67307     }
67308   }
67309
67310 }
67311
67312
67313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67315   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67316   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67317
67318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67319   arg2 = (Dali::SlotObserver *)jarg2;
67320   arg3 = (Dali::CallbackBase *)jarg3;
67321   {
67322     try {
67323       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67324     } catch (std::out_of_range& e) {
67325       {
67326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67327       };
67328     } catch (std::exception& e) {
67329       {
67330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67331       };
67332     } catch (Dali::DaliException e) {
67333       {
67334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67335       };
67336     } catch (...) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67339       };
67340     }
67341   }
67342
67343 }
67344
67345
67346 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) {
67347   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67348   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67349   if (director) {
67350     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);
67351   }
67352 }
67353
67354
67355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67356   void * jresult ;
67357   Dali::Toolkit::Control *arg1 = 0 ;
67358   Dali::Toolkit::Internal::Control *result = 0 ;
67359
67360   arg1 = (Dali::Toolkit::Control *)jarg1;
67361   if (!arg1) {
67362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67363     return 0;
67364   }
67365   {
67366     try {
67367       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67368     } catch (std::out_of_range& e) {
67369       {
67370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67371       };
67372     } catch (std::exception& e) {
67373       {
67374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67375       };
67376     } catch (Dali::DaliException e) {
67377       {
67378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67379       };
67380     } catch (...) {
67381       {
67382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67383       };
67384     }
67385   }
67386
67387   jresult = (void *)result;
67388   return jresult;
67389 }
67390
67391
67392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67393   int jresult ;
67394   int result;
67395
67396   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67397   jresult = (int)result;
67398   return jresult;
67399 }
67400
67401
67402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67403   int jresult ;
67404   int result;
67405
67406   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67407   jresult = (int)result;
67408   return jresult;
67409 }
67410
67411
67412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67413   int jresult ;
67414   int result;
67415
67416   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67417   jresult = (int)result;
67418   return jresult;
67419 }
67420
67421
67422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67423   int jresult ;
67424   int result;
67425
67426   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67427   jresult = (int)result;
67428   return jresult;
67429 }
67430
67431
67432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67433   int jresult ;
67434   int result;
67435
67436   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67437   jresult = (int)result;
67438   return jresult;
67439 }
67440
67441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67442   int jresult ;
67443   int result;
67444
67445   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67446   jresult = (int)result;
67447   return jresult;
67448 }
67449
67450
67451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67452   int jresult ;
67453   int result;
67454
67455   result = (int)Dali::Toolkit::Control::Property::PADDING;
67456   jresult = (int)result;
67457   return jresult;
67458 }
67459
67460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67461   void * jresult ;
67462   Dali::Toolkit::Control::Property *result = 0 ;
67463
67464   {
67465     try {
67466       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67467     } catch (std::out_of_range& e) {
67468       {
67469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (std::exception& e) {
67472       {
67473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (Dali::DaliException e) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67478       };
67479     } catch (...) {
67480       {
67481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67482       };
67483     }
67484   }
67485
67486   jresult = (void *)result;
67487   return jresult;
67488 }
67489
67490
67491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67492   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67493
67494   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67495   {
67496     try {
67497       delete arg1;
67498     } catch (std::out_of_range& e) {
67499       {
67500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67501       };
67502     } catch (std::exception& e) {
67503       {
67504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67505       };
67506     } catch (Dali::DaliException e) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67509       };
67510     } catch (...) {
67511       {
67512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67513       };
67514     }
67515   }
67516
67517 }
67518
67519
67520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67521   void * jresult ;
67522   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67523
67524   {
67525     try {
67526       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67527     } catch (std::out_of_range& e) {
67528       {
67529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (std::exception& e) {
67532       {
67533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67534       };
67535     } catch (Dali::DaliException e) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67538       };
67539     } catch (...) {
67540       {
67541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67542       };
67543     }
67544   }
67545
67546   jresult = (void *)result;
67547   return jresult;
67548 }
67549
67550
67551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67552   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67553
67554   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67555   {
67556     try {
67557       delete arg1;
67558     } catch (std::out_of_range& e) {
67559       {
67560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67561       };
67562     } catch (std::exception& e) {
67563       {
67564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67565       };
67566     } catch (Dali::DaliException e) {
67567       {
67568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67569       };
67570     } catch (...) {
67571       {
67572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67573       };
67574     }
67575   }
67576
67577 }
67578
67579
67580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67581   void * jresult ;
67582   Dali::Toolkit::Control result;
67583
67584   {
67585     try {
67586       result = Dali::Toolkit::Control::New();
67587     } catch (std::out_of_range& e) {
67588       {
67589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67590       };
67591     } catch (std::exception& e) {
67592       {
67593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67594       };
67595     } catch (Dali::DaliException e) {
67596       {
67597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67598       };
67599     } catch (...) {
67600       {
67601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67602       };
67603     }
67604   }
67605
67606   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67607   return jresult;
67608 }
67609
67610
67611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67612   void * jresult ;
67613   Dali::Toolkit::Control *result = 0 ;
67614
67615   {
67616     try {
67617       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67625       };
67626     } catch (Dali::DaliException e) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67633       };
67634     }
67635   }
67636
67637   jresult = (void *)result;
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67643   void * jresult ;
67644   Dali::Toolkit::Control *arg1 = 0 ;
67645   Dali::Toolkit::Control *result = 0 ;
67646
67647   arg1 = (Dali::Toolkit::Control *)jarg1;
67648   if (!arg1) {
67649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67650     return 0;
67651   }
67652   {
67653     try {
67654       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67655     } catch (std::out_of_range& e) {
67656       {
67657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67658       };
67659     } catch (std::exception& e) {
67660       {
67661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (Dali::DaliException e) {
67664       {
67665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67666       };
67667     } catch (...) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67670       };
67671     }
67672   }
67673
67674   jresult = (void *)result;
67675   return jresult;
67676 }
67677
67678
67679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67680   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67681
67682   arg1 = (Dali::Toolkit::Control *)jarg1;
67683   {
67684     try {
67685       delete arg1;
67686     } catch (std::out_of_range& e) {
67687       {
67688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67689       };
67690     } catch (std::exception& e) {
67691       {
67692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67693       };
67694     } catch (Dali::DaliException e) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67697       };
67698     } catch (...) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67701       };
67702     }
67703   }
67704
67705 }
67706
67707
67708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67709   void * jresult ;
67710   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67711   Dali::Toolkit::Control *arg2 = 0 ;
67712   Dali::Toolkit::Control *result = 0 ;
67713
67714   arg1 = (Dali::Toolkit::Control *)jarg1;
67715   arg2 = (Dali::Toolkit::Control *)jarg2;
67716   if (!arg2) {
67717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67718     return 0;
67719   }
67720   {
67721     try {
67722       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67723     } catch (std::out_of_range& e) {
67724       {
67725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67726       };
67727     } catch (std::exception& e) {
67728       {
67729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (Dali::DaliException e) {
67732       {
67733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67734       };
67735     } catch (...) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67738       };
67739     }
67740   }
67741
67742   jresult = (void *)result;
67743   return jresult;
67744 }
67745
67746
67747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67748   void * jresult ;
67749   Dali::BaseHandle arg1 ;
67750   Dali::BaseHandle *argp1 ;
67751   Dali::Toolkit::Control result;
67752
67753   argp1 = (Dali::BaseHandle *)jarg1;
67754   if (!argp1) {
67755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67756     return 0;
67757   }
67758   arg1 = *argp1;
67759   {
67760     try {
67761       result = Dali::Toolkit::Control::DownCast(arg1);
67762     } catch (std::out_of_range& e) {
67763       {
67764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67765       };
67766     } catch (std::exception& e) {
67767       {
67768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67769       };
67770     } catch (Dali::DaliException e) {
67771       {
67772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67773       };
67774     } catch (...) {
67775       {
67776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67777       };
67778     }
67779   }
67780
67781   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67782   return jresult;
67783 }
67784
67785
67786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67788
67789   arg1 = (Dali::Toolkit::Control *)jarg1;
67790   {
67791     try {
67792       (arg1)->SetKeyInputFocus();
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67800       };
67801     } catch (Dali::DaliException e) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67804       };
67805     } catch (...) {
67806       {
67807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67808       };
67809     }
67810   }
67811
67812 }
67813
67814
67815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67816   unsigned int jresult ;
67817   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67818   bool result;
67819
67820   arg1 = (Dali::Toolkit::Control *)jarg1;
67821   {
67822     try {
67823       result = (bool)(arg1)->HasKeyInputFocus();
67824     } catch (std::out_of_range& e) {
67825       {
67826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67827       };
67828     } catch (std::exception& e) {
67829       {
67830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67831       };
67832     } catch (Dali::DaliException e) {
67833       {
67834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67835       };
67836     } catch (...) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67839       };
67840     }
67841   }
67842
67843   jresult = result;
67844   return jresult;
67845 }
67846
67847
67848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67849   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67850
67851   arg1 = (Dali::Toolkit::Control *)jarg1;
67852   {
67853     try {
67854       (arg1)->ClearKeyInputFocus();
67855     } catch (std::out_of_range& e) {
67856       {
67857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67858       };
67859     } catch (std::exception& e) {
67860       {
67861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67862       };
67863     } catch (Dali::DaliException e) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67866       };
67867     } catch (...) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67870       };
67871     }
67872   }
67873
67874 }
67875
67876
67877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67878   void * jresult ;
67879   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67880   Dali::PinchGestureDetector result;
67881
67882   arg1 = (Dali::Toolkit::Control *)jarg1;
67883   {
67884     try {
67885       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67886     } catch (std::out_of_range& e) {
67887       {
67888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67889       };
67890     } catch (std::exception& e) {
67891       {
67892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (Dali::DaliException e) {
67895       {
67896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67901       };
67902     }
67903   }
67904
67905   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67906   return jresult;
67907 }
67908
67909
67910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67911   void * jresult ;
67912   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67913   Dali::PanGestureDetector result;
67914
67915   arg1 = (Dali::Toolkit::Control *)jarg1;
67916   {
67917     try {
67918       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67919     } catch (std::out_of_range& e) {
67920       {
67921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (std::exception& e) {
67924       {
67925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67926       };
67927     } catch (Dali::DaliException e) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67930       };
67931     } catch (...) {
67932       {
67933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67934       };
67935     }
67936   }
67937
67938   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67939   return jresult;
67940 }
67941
67942
67943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67944   void * jresult ;
67945   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67946   Dali::TapGestureDetector result;
67947
67948   arg1 = (Dali::Toolkit::Control *)jarg1;
67949   {
67950     try {
67951       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67952     } catch (std::out_of_range& e) {
67953       {
67954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67955       };
67956     } catch (std::exception& e) {
67957       {
67958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67959       };
67960     } catch (Dali::DaliException e) {
67961       {
67962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67963       };
67964     } catch (...) {
67965       {
67966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67967       };
67968     }
67969   }
67970
67971   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67972   return jresult;
67973 }
67974
67975
67976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67977   void * jresult ;
67978   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67979   Dali::LongPressGestureDetector result;
67980
67981   arg1 = (Dali::Toolkit::Control *)jarg1;
67982   {
67983     try {
67984       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67985     } catch (std::out_of_range& e) {
67986       {
67987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67988       };
67989     } catch (std::exception& e) {
67990       {
67991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (Dali::DaliException e) {
67994       {
67995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67996       };
67997     } catch (...) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68000       };
68001     }
68002   }
68003
68004   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68005   return jresult;
68006 }
68007
68008
68009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68010   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68011   std::string *arg2 = 0 ;
68012
68013   arg1 = (Dali::Toolkit::Control *)jarg1;
68014   if (!jarg2) {
68015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68016     return ;
68017   }
68018   std::string arg2_str(jarg2);
68019   arg2 = &arg2_str;
68020   {
68021     try {
68022       (arg1)->SetStyleName((std::string const &)*arg2);
68023     } catch (std::out_of_range& e) {
68024       {
68025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68026       };
68027     } catch (std::exception& e) {
68028       {
68029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68030       };
68031     } catch (Dali::DaliException e) {
68032       {
68033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68034       };
68035     } catch (...) {
68036       {
68037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68038       };
68039     }
68040   }
68041
68042
68043   //argout typemap for const std::string&
68044
68045 }
68046
68047
68048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68049   char * jresult ;
68050   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68051   std::string *result = 0 ;
68052
68053   arg1 = (Dali::Toolkit::Control *)jarg1;
68054   {
68055     try {
68056       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68057     } catch (std::out_of_range& e) {
68058       {
68059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68060       };
68061     } catch (std::exception& e) {
68062       {
68063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68064       };
68065     } catch (Dali::DaliException e) {
68066       {
68067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68068       };
68069     } catch (...) {
68070       {
68071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68072       };
68073     }
68074   }
68075
68076   jresult = SWIG_csharp_string_callback(result->c_str());
68077   return jresult;
68078 }
68079
68080
68081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68082   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68083   Dali::Vector4 *arg2 = 0 ;
68084
68085   arg1 = (Dali::Toolkit::Control *)jarg1;
68086   arg2 = (Dali::Vector4 *)jarg2;
68087   if (!arg2) {
68088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68089     return ;
68090   }
68091   {
68092     try {
68093       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68094     } catch (std::out_of_range& e) {
68095       {
68096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68097       };
68098     } catch (std::exception& e) {
68099       {
68100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68101       };
68102     } catch (Dali::DaliException e) {
68103       {
68104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68105       };
68106     } catch (...) {
68107       {
68108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68109       };
68110     }
68111   }
68112
68113 }
68114
68115
68116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68117   void * jresult ;
68118   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68119   Dali::Vector4 result;
68120
68121   arg1 = (Dali::Toolkit::Control *)jarg1;
68122   {
68123     try {
68124       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68125     } catch (std::out_of_range& e) {
68126       {
68127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68128       };
68129     } catch (std::exception& e) {
68130       {
68131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68132       };
68133     } catch (Dali::DaliException e) {
68134       {
68135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68136       };
68137     } catch (...) {
68138       {
68139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68140       };
68141     }
68142   }
68143
68144   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68145   return jresult;
68146 }
68147
68148
68149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68150   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68151   Dali::Image arg2 ;
68152   Dali::Image *argp2 ;
68153
68154   arg1 = (Dali::Toolkit::Control *)jarg1;
68155   argp2 = (Dali::Image *)jarg2;
68156   if (!argp2) {
68157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68158     return ;
68159   }
68160   arg2 = *argp2;
68161   {
68162     try {
68163       (arg1)->SetBackgroundImage(arg2);
68164     } catch (std::out_of_range& e) {
68165       {
68166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68167       };
68168     } catch (std::exception& e) {
68169       {
68170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68171       };
68172     } catch (Dali::DaliException e) {
68173       {
68174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68175       };
68176     } catch (...) {
68177       {
68178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68179       };
68180     }
68181   }
68182
68183 }
68184
68185
68186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68187   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68188
68189   arg1 = (Dali::Toolkit::Control *)jarg1;
68190   {
68191     try {
68192       (arg1)->ClearBackground();
68193     } catch (std::out_of_range& e) {
68194       {
68195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68196       };
68197     } catch (std::exception& e) {
68198       {
68199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68200       };
68201     } catch (Dali::DaliException e) {
68202       {
68203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68204       };
68205     } catch (...) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68208       };
68209     }
68210   }
68211
68212 }
68213
68214
68215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68216   void * jresult ;
68217   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68218   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68219
68220   arg1 = (Dali::Toolkit::Control *)jarg1;
68221   {
68222     try {
68223       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68224     } catch (std::out_of_range& e) {
68225       {
68226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68227       };
68228     } catch (std::exception& e) {
68229       {
68230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68231       };
68232     } catch (Dali::DaliException e) {
68233       {
68234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68235       };
68236     } catch (...) {
68237       {
68238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68239       };
68240     }
68241   }
68242
68243   jresult = (void *)result;
68244   return jresult;
68245 }
68246
68247
68248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68249   void * jresult ;
68250   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68251   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68252
68253   arg1 = (Dali::Toolkit::Control *)jarg1;
68254   {
68255     try {
68256       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68257     } catch (std::out_of_range& e) {
68258       {
68259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68260       };
68261     } catch (std::exception& e) {
68262       {
68263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68264       };
68265     } catch (Dali::DaliException e) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68268       };
68269     } catch (...) {
68270       {
68271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68272       };
68273     }
68274   }
68275
68276   jresult = (void *)result;
68277   return jresult;
68278 }
68279
68280
68281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68282   void * jresult ;
68283   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68284   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68285
68286   arg1 = (Dali::Toolkit::Control *)jarg1;
68287   {
68288     try {
68289       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68290     } catch (std::out_of_range& e) {
68291       {
68292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68293       };
68294     } catch (std::exception& e) {
68295       {
68296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68297       };
68298     } catch (Dali::DaliException e) {
68299       {
68300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68301       };
68302     } catch (...) {
68303       {
68304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68305       };
68306     }
68307   }
68308
68309   jresult = (void *)result;
68310   return jresult;
68311 }
68312
68313
68314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68315   void * jresult ;
68316   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68317   Dali::Toolkit::Control *result = 0 ;
68318
68319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68320   if (!arg1) {
68321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68322     return 0;
68323   }
68324   {
68325     try {
68326       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (Dali::DaliException e) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68338       };
68339     } catch (...) {
68340       {
68341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68342       };
68343     }
68344   }
68345
68346   jresult = (void *)result;
68347   return jresult;
68348 }
68349
68350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68351 {
68352   int jresult;
68353   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68354   arg1 = (Dali::Toolkit::Control *)jarg1;
68355
68356   if (!arg1) {
68357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68358     return 0;
68359   }
68360
68361   Dali::Property::Index arg2 = 0 ;
68362   arg2 = (Dali::Property::Index)jarg2;
68363
68364   Toolkit::Visual::ResourceStatus result;
68365   {
68366     try {
68367       result = arg1->GetVisualResourceStatus(arg2);
68368     } catch (std::out_of_range& e) {
68369       {
68370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68371       };
68372     } catch (std::exception& e) {
68373       {
68374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68375       };
68376     } catch (...) {
68377       {
68378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68379       };
68380     }
68381   }
68382   jresult = (int)(result);
68383   return jresult;
68384 }
68385
68386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68387 {
68388   void * jresult;
68389   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68390   arg1 = (Dali::Toolkit::Control *)jarg1;
68391
68392   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68393
68394   Dali::Toolkit::TransitionData *arg2 = 0 ;
68395   Dali::Animation result;
68396
68397   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68398   if (!arg2) {
68399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68400     return 0;
68401   }
68402   {
68403     try {
68404       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68405     } catch (std::out_of_range& e) {
68406       {
68407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (std::exception& e) {
68410       {
68411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68412       };
68413     } catch (Dali::DaliException e) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68416       };
68417     } catch (...) {
68418       {
68419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68420       };
68421     }
68422   }
68423
68424   jresult = new Dali::Animation((const Dali::Animation &)result);
68425   return jresult;
68426 }
68427
68428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68429 {
68430   Dali::Toolkit::Control arg1;
68431   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68432
68433   if (!argp1) {
68434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68435   }
68436   arg1 = *argp1;
68437
68438   Dali::Property::Index arg2 = 0 ;
68439   arg2 = (Dali::Property::Index)jarg2;
68440
68441   Dali::Property::Index arg3 = 0 ;
68442   arg3 = (Dali::Property::Index)jarg3;
68443
68444   Dali::Property::Value arg4;
68445   arg4 = (Dali::Property::Value *)jarg4;
68446
68447   {
68448     try {
68449       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68450     } catch (std::out_of_range& e) {
68451       {
68452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68453       };
68454     } catch (std::exception& e) {
68455       {
68456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68457       };
68458     } catch (...) {
68459       {
68460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68461       };
68462     }
68463   }
68464
68465
68466 }
68467
68468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68469   void * jresult ;
68470   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68471   Dali::Toolkit::LayoutItem result;
68472
68473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68474   if (!arg1) {
68475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68476     return 0;
68477   }
68478   {
68479     try {
68480       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68481     } catch (std::out_of_range& e) {
68482       {
68483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68484       };
68485     } catch (std::exception& e) {
68486       {
68487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68488       };
68489     } catch (...) {
68490       {
68491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68492       };
68493     }
68494   }
68495   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68496   return jresult;
68497 }
68498
68499
68500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68501   void * jresult ;
68502   Dali::Toolkit::Control arg1 ;
68503   Dali::Toolkit::Control *argp1 ;
68504   Dali::Toolkit::LayoutItem result;
68505
68506   argp1 = (Dali::Toolkit::Control *)jarg1;
68507   if (!argp1) {
68508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68509     return 0;
68510   }
68511   arg1 = *argp1;
68512   {
68513     try {
68514       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68515     } catch (std::out_of_range& e) {
68516       {
68517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (std::exception& e) {
68520       {
68521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68522       };
68523     } catch (...) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68526       };
68527     }
68528   }
68529   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68530   return jresult;
68531 }
68532
68533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68534   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68535   Dali::Toolkit::LayoutItem arg2 ;
68536   Dali::Toolkit::LayoutItem *argp2 ;
68537
68538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68539   if (!arg1) {
68540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68541     return ;
68542   }
68543   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68544   if (!argp2) {
68545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68546     return ;
68547   }
68548   arg2 = *argp2;
68549   {
68550     try {
68551       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68552     } catch (std::out_of_range& e) {
68553       {
68554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68555       };
68556     } catch (std::exception& e) {
68557       {
68558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68559       };
68560     } catch (...) {
68561       {
68562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68563       };
68564     }
68565   }
68566 }
68567
68568
68569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68570   Dali::Toolkit::Control arg1 ;
68571   Dali::Toolkit::LayoutItem arg2 ;
68572   Dali::Toolkit::Control *argp1 ;
68573   Dali::Toolkit::LayoutItem *argp2 ;
68574
68575   argp1 = (Dali::Toolkit::Control *)jarg1;
68576   if (!argp1) {
68577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68578     return ;
68579   }
68580   arg1 = *argp1;
68581   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68582   if (!argp2) {
68583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68584     return ;
68585   }
68586   arg2 = *argp2;
68587   {
68588     try {
68589       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68590     } catch (std::out_of_range& e) {
68591       {
68592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68593       };
68594     } catch (std::exception& e) {
68595       {
68596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68601       };
68602     }
68603   }
68604 }
68605
68606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68607   void * jresult ;
68608   Dali::Toolkit::Control *arg1 = 0 ;
68609   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68610
68611   arg1 = (Dali::Toolkit::Control *)jarg1;
68612   if (!arg1) {
68613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68614     return 0;
68615   }
68616   {
68617     try {
68618       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68619     } catch (std::out_of_range& e) {
68620       {
68621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68622       };
68623     } catch (std::exception& e) {
68624       {
68625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68626       };
68627     } catch (Dali::DaliException e) {
68628       {
68629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68630       };
68631     } catch (...) {
68632       {
68633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68634       };
68635     }
68636   }
68637
68638   jresult = (void *)result;
68639   return jresult;
68640 }
68641
68642
68643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68644   unsigned int jresult ;
68645   Dali::Toolkit::Control *arg1 = 0 ;
68646   bool result;
68647
68648   arg1 = (Dali::Toolkit::Control *)jarg1;
68649   if (!arg1) {
68650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68651     return 0;
68652   }
68653   {
68654     try {
68655       result = (bool)arg1->IsResourceReady();
68656     } catch (std::out_of_range& e) {
68657       {
68658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68659       };
68660     } catch (std::exception& e) {
68661       {
68662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68663       };
68664     } catch (Dali::DaliException e) {
68665       {
68666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68667       };
68668     } catch (...) {
68669       {
68670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68671       };
68672     }
68673   }
68674
68675   jresult = result;
68676   return jresult;
68677 }
68678
68679
68680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68681   void * jresult ;
68682   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68683
68684   {
68685     try {
68686       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68687     } catch (std::out_of_range& e) {
68688       {
68689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68690       };
68691     } catch (std::exception& e) {
68692       {
68693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68694       };
68695     } catch (Dali::DaliException e) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68698       };
68699     } catch (...) {
68700       {
68701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68702       };
68703     }
68704   }
68705
68706   jresult = (void *)result;
68707   return jresult;
68708 }
68709
68710
68711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68712   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68713
68714   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68715   {
68716     try {
68717       delete arg1;
68718     } catch (std::out_of_range& e) {
68719       {
68720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68721       };
68722     } catch (std::exception& e) {
68723       {
68724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68725       };
68726     } catch (Dali::DaliException e) {
68727       {
68728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68729       };
68730     } catch (...) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68733       };
68734     }
68735   }
68736
68737 }
68738
68739
68740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68741   void * jresult ;
68742   Dali::Toolkit::KeyInputFocusManager result;
68743
68744   {
68745     try {
68746       result = Dali::Toolkit::KeyInputFocusManager::Get();
68747     } catch (std::out_of_range& e) {
68748       {
68749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68750       };
68751     } catch (std::exception& e) {
68752       {
68753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68754       };
68755     } catch (Dali::DaliException e) {
68756       {
68757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68758       };
68759     } catch (...) {
68760       {
68761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68762       };
68763     }
68764   }
68765
68766   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68767   return jresult;
68768 }
68769
68770
68771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68772   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68773   Dali::Toolkit::Control arg2 ;
68774   Dali::Toolkit::Control *argp2 ;
68775
68776   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68777   argp2 = (Dali::Toolkit::Control *)jarg2;
68778   if (!argp2) {
68779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68780     return ;
68781   }
68782   arg2 = *argp2;
68783   {
68784     try {
68785       (arg1)->SetFocus(arg2);
68786     } catch (std::out_of_range& e) {
68787       {
68788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68789       };
68790     } catch (std::exception& e) {
68791       {
68792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68793       };
68794     } catch (Dali::DaliException e) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68797       };
68798     } catch (...) {
68799       {
68800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68801       };
68802     }
68803   }
68804
68805 }
68806
68807
68808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68809   void * jresult ;
68810   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68811   Dali::Toolkit::Control result;
68812
68813   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68814   {
68815     try {
68816       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68817     } catch (std::out_of_range& e) {
68818       {
68819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68820       };
68821     } catch (std::exception& e) {
68822       {
68823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68824       };
68825     } catch (Dali::DaliException e) {
68826       {
68827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68828       };
68829     } catch (...) {
68830       {
68831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68832       };
68833     }
68834   }
68835
68836   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68837   return jresult;
68838 }
68839
68840
68841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68842   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68843   Dali::Toolkit::Control arg2 ;
68844   Dali::Toolkit::Control *argp2 ;
68845
68846   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68847   argp2 = (Dali::Toolkit::Control *)jarg2;
68848   if (!argp2) {
68849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68850     return ;
68851   }
68852   arg2 = *argp2;
68853   {
68854     try {
68855       (arg1)->RemoveFocus(arg2);
68856     } catch (std::out_of_range& e) {
68857       {
68858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68859       };
68860     } catch (std::exception& e) {
68861       {
68862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68863       };
68864     } catch (Dali::DaliException e) {
68865       {
68866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68867       };
68868     } catch (...) {
68869       {
68870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68871       };
68872     }
68873   }
68874
68875 }
68876
68877
68878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68879   void * jresult ;
68880   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68881   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68882
68883   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68884   {
68885     try {
68886       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68887     } catch (std::out_of_range& e) {
68888       {
68889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68890       };
68891     } catch (std::exception& e) {
68892       {
68893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68894       };
68895     } catch (Dali::DaliException e) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68898       };
68899     } catch (...) {
68900       {
68901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68902       };
68903     }
68904   }
68905
68906   jresult = (void *)result;
68907   return jresult;
68908 }
68909
68910
68911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68912   void * jresult ;
68913   Dali::Toolkit::Alignment::Padding *result = 0 ;
68914
68915   {
68916     try {
68917       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68918     } catch (std::out_of_range& e) {
68919       {
68920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68921       };
68922     } catch (std::exception& e) {
68923       {
68924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68925       };
68926     } catch (Dali::DaliException e) {
68927       {
68928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68929       };
68930     } catch (...) {
68931       {
68932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68933       };
68934     }
68935   }
68936
68937   jresult = (void *)result;
68938   return jresult;
68939 }
68940
68941
68942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68943   void * jresult ;
68944   float arg1 ;
68945   float arg2 ;
68946   float arg3 ;
68947   float arg4 ;
68948   Dali::Toolkit::Alignment::Padding *result = 0 ;
68949
68950   arg1 = (float)jarg1;
68951   arg2 = (float)jarg2;
68952   arg3 = (float)jarg3;
68953   arg4 = (float)jarg4;
68954   {
68955     try {
68956       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68957     } catch (std::out_of_range& e) {
68958       {
68959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68960       };
68961     } catch (std::exception& e) {
68962       {
68963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68964       };
68965     } catch (Dali::DaliException e) {
68966       {
68967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68968       };
68969     } catch (...) {
68970       {
68971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68972       };
68973     }
68974   }
68975
68976   jresult = (void *)result;
68977   return jresult;
68978 }
68979
68980
68981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68982   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68983   float arg2 ;
68984
68985   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68986   arg2 = (float)jarg2;
68987   if (arg1) (arg1)->left = arg2;
68988 }
68989
68990
68991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68992   float jresult ;
68993   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68994   float result;
68995
68996   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68997   result = (float) ((arg1)->left);
68998   jresult = result;
68999   return jresult;
69000 }
69001
69002
69003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69004   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69005   float arg2 ;
69006
69007   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69008   arg2 = (float)jarg2;
69009   if (arg1) (arg1)->right = arg2;
69010 }
69011
69012
69013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69014   float jresult ;
69015   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69016   float result;
69017
69018   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69019   result = (float) ((arg1)->right);
69020   jresult = result;
69021   return jresult;
69022 }
69023
69024
69025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69026   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69027   float arg2 ;
69028
69029   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69030   arg2 = (float)jarg2;
69031   if (arg1) (arg1)->top = arg2;
69032 }
69033
69034
69035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69036   float jresult ;
69037   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69038   float result;
69039
69040   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69041   result = (float) ((arg1)->top);
69042   jresult = result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69048   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69049   float arg2 ;
69050
69051   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69052   arg2 = (float)jarg2;
69053   if (arg1) (arg1)->bottom = arg2;
69054 }
69055
69056
69057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69058   float jresult ;
69059   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69060   float result;
69061
69062   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69063   result = (float) ((arg1)->bottom);
69064   jresult = result;
69065   return jresult;
69066 }
69067
69068
69069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69070   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69071
69072   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69073   {
69074     try {
69075       delete arg1;
69076     } catch (std::out_of_range& e) {
69077       {
69078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69079       };
69080     } catch (std::exception& e) {
69081       {
69082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69083       };
69084     } catch (Dali::DaliException e) {
69085       {
69086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69087       };
69088     } catch (...) {
69089       {
69090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69091       };
69092     }
69093   }
69094
69095 }
69096
69097
69098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69099   void * jresult ;
69100   Dali::Toolkit::Alignment *result = 0 ;
69101
69102   {
69103     try {
69104       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69105     } catch (std::out_of_range& e) {
69106       {
69107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69108       };
69109     } catch (std::exception& e) {
69110       {
69111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69112       };
69113     } catch (Dali::DaliException e) {
69114       {
69115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69116       };
69117     } catch (...) {
69118       {
69119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69120       };
69121     }
69122   }
69123
69124   jresult = (void *)result;
69125   return jresult;
69126 }
69127
69128
69129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69130   void * jresult ;
69131   Dali::Toolkit::Alignment::Type arg1 ;
69132   Dali::Toolkit::Alignment::Type arg2 ;
69133   Dali::Toolkit::Alignment result;
69134
69135   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69136   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69137   {
69138     try {
69139       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69140     } catch (std::out_of_range& e) {
69141       {
69142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69143       };
69144     } catch (std::exception& e) {
69145       {
69146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69147       };
69148     } catch (Dali::DaliException e) {
69149       {
69150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69151       };
69152     } catch (...) {
69153       {
69154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69155       };
69156     }
69157   }
69158
69159   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69160   return jresult;
69161 }
69162
69163
69164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69165   void * jresult ;
69166   Dali::Toolkit::Alignment::Type arg1 ;
69167   Dali::Toolkit::Alignment result;
69168
69169   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69170   {
69171     try {
69172       result = Dali::Toolkit::Alignment::New(arg1);
69173     } catch (std::out_of_range& e) {
69174       {
69175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69176       };
69177     } catch (std::exception& e) {
69178       {
69179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69180       };
69181     } catch (Dali::DaliException e) {
69182       {
69183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69184       };
69185     } catch (...) {
69186       {
69187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69188       };
69189     }
69190   }
69191
69192   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69193   return jresult;
69194 }
69195
69196
69197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69198   void * jresult ;
69199   Dali::Toolkit::Alignment result;
69200
69201   {
69202     try {
69203       result = Dali::Toolkit::Alignment::New();
69204     } catch (std::out_of_range& e) {
69205       {
69206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69207       };
69208     } catch (std::exception& e) {
69209       {
69210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69211       };
69212     } catch (Dali::DaliException e) {
69213       {
69214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69215       };
69216     } catch (...) {
69217       {
69218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69219       };
69220     }
69221   }
69222
69223   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69224   return jresult;
69225 }
69226
69227
69228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69229   void * jresult ;
69230   Dali::Toolkit::Alignment *arg1 = 0 ;
69231   Dali::Toolkit::Alignment *result = 0 ;
69232
69233   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69234   if (!arg1) {
69235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69236     return 0;
69237   }
69238   {
69239     try {
69240       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69241     } catch (std::out_of_range& e) {
69242       {
69243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69244       };
69245     } catch (std::exception& e) {
69246       {
69247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (Dali::DaliException e) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69256       };
69257     }
69258   }
69259
69260   jresult = (void *)result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69266   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69267
69268   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69269   {
69270     try {
69271       delete arg1;
69272     } catch (std::out_of_range& e) {
69273       {
69274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69275       };
69276     } catch (std::exception& e) {
69277       {
69278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69279       };
69280     } catch (Dali::DaliException e) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69287       };
69288     }
69289   }
69290
69291 }
69292
69293
69294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69295   void * jresult ;
69296   Dali::BaseHandle arg1 ;
69297   Dali::BaseHandle *argp1 ;
69298   Dali::Toolkit::Alignment result;
69299
69300   argp1 = (Dali::BaseHandle *)jarg1;
69301   if (!argp1) {
69302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69303     return 0;
69304   }
69305   arg1 = *argp1;
69306   {
69307     try {
69308       result = Dali::Toolkit::Alignment::DownCast(arg1);
69309     } catch (std::out_of_range& e) {
69310       {
69311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69312       };
69313     } catch (std::exception& e) {
69314       {
69315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (Dali::DaliException e) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69320       };
69321     } catch (...) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69324       };
69325     }
69326   }
69327
69328   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69329   return jresult;
69330 }
69331
69332
69333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69334   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69335   Dali::Toolkit::Alignment::Type arg2 ;
69336
69337   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69338   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69339   {
69340     try {
69341       (arg1)->SetAlignmentType(arg2);
69342     } catch (std::out_of_range& e) {
69343       {
69344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69345       };
69346     } catch (std::exception& e) {
69347       {
69348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69349       };
69350     } catch (Dali::DaliException e) {
69351       {
69352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69353       };
69354     } catch (...) {
69355       {
69356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69357       };
69358     }
69359   }
69360
69361 }
69362
69363
69364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69365   int jresult ;
69366   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69367   Dali::Toolkit::Alignment::Type result;
69368
69369   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69370   {
69371     try {
69372       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69373     } catch (std::out_of_range& e) {
69374       {
69375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69376       };
69377     } catch (std::exception& e) {
69378       {
69379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (Dali::DaliException e) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69384       };
69385     } catch (...) {
69386       {
69387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69388       };
69389     }
69390   }
69391
69392   jresult = (int)result;
69393   return jresult;
69394 }
69395
69396
69397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69398   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69399   Dali::Toolkit::Alignment::Scaling arg2 ;
69400
69401   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69402   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69403   {
69404     try {
69405       (arg1)->SetScaling(arg2);
69406     } catch (std::out_of_range& e) {
69407       {
69408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69409       };
69410     } catch (std::exception& e) {
69411       {
69412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69413       };
69414     } catch (Dali::DaliException e) {
69415       {
69416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69417       };
69418     } catch (...) {
69419       {
69420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69421       };
69422     }
69423   }
69424
69425 }
69426
69427
69428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69429   int jresult ;
69430   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69431   Dali::Toolkit::Alignment::Scaling result;
69432
69433   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69434   {
69435     try {
69436       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69437     } catch (std::out_of_range& e) {
69438       {
69439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (std::exception& e) {
69442       {
69443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69444       };
69445     } catch (Dali::DaliException e) {
69446       {
69447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69448       };
69449     } catch (...) {
69450       {
69451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69452       };
69453     }
69454   }
69455
69456   jresult = (int)result;
69457   return jresult;
69458 }
69459
69460
69461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69462   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69463   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69464
69465   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69466   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69467   if (!arg2) {
69468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69469     return ;
69470   }
69471   {
69472     try {
69473       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69474     } catch (std::out_of_range& e) {
69475       {
69476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69477       };
69478     } catch (std::exception& e) {
69479       {
69480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69481       };
69482     } catch (Dali::DaliException e) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69485       };
69486     } catch (...) {
69487       {
69488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69489       };
69490     }
69491   }
69492
69493 }
69494
69495
69496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69497   void * jresult ;
69498   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69499   Dali::Toolkit::Alignment::Padding *result = 0 ;
69500
69501   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69502   {
69503     try {
69504       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69505     } catch (std::out_of_range& e) {
69506       {
69507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69508       };
69509     } catch (std::exception& e) {
69510       {
69511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69512       };
69513     } catch (Dali::DaliException e) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69516       };
69517     } catch (...) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69520       };
69521     }
69522   }
69523
69524   jresult = (void *)result;
69525   return jresult;
69526 }
69527
69528
69529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69530   void * jresult ;
69531   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69532   Dali::Toolkit::Alignment *arg2 = 0 ;
69533   Dali::Toolkit::Alignment *result = 0 ;
69534
69535   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69536   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69537   if (!arg2) {
69538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69539     return 0;
69540   }
69541   {
69542     try {
69543       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69544     } catch (std::out_of_range& e) {
69545       {
69546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69547       };
69548     } catch (std::exception& e) {
69549       {
69550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69551       };
69552     } catch (Dali::DaliException e) {
69553       {
69554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69555       };
69556     } catch (...) {
69557       {
69558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69559       };
69560     }
69561   }
69562
69563   jresult = (void *)result;
69564   return jresult;
69565 }
69566
69567
69568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69569   int jresult ;
69570   int result;
69571
69572   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69573   jresult = (int)result;
69574   return jresult;
69575 }
69576
69577
69578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69579   int jresult ;
69580   int result;
69581
69582   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69583   jresult = (int)result;
69584   return jresult;
69585 }
69586
69587
69588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69589   int jresult ;
69590   int result;
69591
69592   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69593   jresult = (int)result;
69594   return jresult;
69595 }
69596
69597
69598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69599   int jresult ;
69600   int result;
69601
69602   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69603   jresult = (int)result;
69604   return jresult;
69605 }
69606
69607
69608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69609   int jresult ;
69610   int result;
69611
69612   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69613   jresult = (int)result;
69614   return jresult;
69615 }
69616
69617
69618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69619   int jresult ;
69620   int result;
69621
69622   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69623   jresult = (int)result;
69624   return jresult;
69625 }
69626
69627
69628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69629   int jresult ;
69630   int result;
69631
69632   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69633   jresult = (int)result;
69634   return jresult;
69635 }
69636
69637
69638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69639   int jresult ;
69640   int result;
69641
69642   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69643   jresult = (int)result;
69644   return jresult;
69645 }
69646
69647
69648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69649   int jresult ;
69650   int result;
69651
69652   result = (int)Dali::Toolkit::Button::Property::LABEL;
69653   jresult = (int)result;
69654   return jresult;
69655 }
69656
69657
69658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69659   int jresult ;
69660   int result;
69661
69662   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69663   jresult = (int)result;
69664   return jresult;
69665 }
69666
69667
69668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69669   void * jresult ;
69670   Dali::Toolkit::Button::Property *result = 0 ;
69671
69672   {
69673     try {
69674       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69675     } catch (std::out_of_range& e) {
69676       {
69677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (std::exception& e) {
69680       {
69681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69682       };
69683     } catch (Dali::DaliException e) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69686       };
69687     } catch (...) {
69688       {
69689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69690       };
69691     }
69692   }
69693
69694   jresult = (void *)result;
69695   return jresult;
69696 }
69697
69698
69699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69700   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69701
69702   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69703   {
69704     try {
69705       delete arg1;
69706     } catch (std::out_of_range& e) {
69707       {
69708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69709       };
69710     } catch (std::exception& e) {
69711       {
69712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69713       };
69714     } catch (Dali::DaliException e) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69717       };
69718     } catch (...) {
69719       {
69720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69721       };
69722     }
69723   }
69724
69725 }
69726
69727
69728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69729   void * jresult ;
69730   Dali::Toolkit::Button *result = 0 ;
69731
69732   {
69733     try {
69734       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69735     } catch (std::out_of_range& e) {
69736       {
69737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69738       };
69739     } catch (std::exception& e) {
69740       {
69741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69742       };
69743     } catch (Dali::DaliException e) {
69744       {
69745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69750       };
69751     }
69752   }
69753
69754   jresult = (void *)result;
69755   return jresult;
69756 }
69757
69758
69759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69760   void * jresult ;
69761   Dali::Toolkit::Button *arg1 = 0 ;
69762   Dali::Toolkit::Button *result = 0 ;
69763
69764   arg1 = (Dali::Toolkit::Button *)jarg1;
69765   if (!arg1) {
69766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69767     return 0;
69768   }
69769   {
69770     try {
69771       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69772     } catch (std::out_of_range& e) {
69773       {
69774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69775       };
69776     } catch (std::exception& e) {
69777       {
69778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69779       };
69780     } catch (Dali::DaliException e) {
69781       {
69782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69787       };
69788     }
69789   }
69790
69791   jresult = (void *)result;
69792   return jresult;
69793 }
69794
69795
69796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69797   void * jresult ;
69798   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69799   Dali::Toolkit::Button *arg2 = 0 ;
69800   Dali::Toolkit::Button *result = 0 ;
69801
69802   arg1 = (Dali::Toolkit::Button *)jarg1;
69803   arg2 = (Dali::Toolkit::Button *)jarg2;
69804   if (!arg2) {
69805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69806     return 0;
69807   }
69808   {
69809     try {
69810       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69811     } catch (std::out_of_range& e) {
69812       {
69813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69814       };
69815     } catch (std::exception& e) {
69816       {
69817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69818       };
69819     } catch (Dali::DaliException e) {
69820       {
69821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69822       };
69823     } catch (...) {
69824       {
69825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69826       };
69827     }
69828   }
69829
69830   jresult = (void *)result;
69831   return jresult;
69832 }
69833
69834
69835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69836   void * jresult ;
69837   Dali::BaseHandle arg1 ;
69838   Dali::BaseHandle *argp1 ;
69839   Dali::Toolkit::Button result;
69840
69841   argp1 = (Dali::BaseHandle *)jarg1;
69842   if (!argp1) {
69843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69844     return 0;
69845   }
69846   arg1 = *argp1;
69847   {
69848     try {
69849       result = Dali::Toolkit::Button::DownCast(arg1);
69850     } catch (std::out_of_range& e) {
69851       {
69852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69853       };
69854     } catch (std::exception& e) {
69855       {
69856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69857       };
69858     } catch (Dali::DaliException e) {
69859       {
69860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69861       };
69862     } catch (...) {
69863       {
69864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69865       };
69866     }
69867   }
69868
69869   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69870   return jresult;
69871 }
69872
69873
69874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69875   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69876
69877   arg1 = (Dali::Toolkit::Button *)jarg1;
69878   {
69879     try {
69880       delete arg1;
69881     } catch (std::out_of_range& e) {
69882       {
69883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69884       };
69885     } catch (std::exception& e) {
69886       {
69887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69888       };
69889     } catch (Dali::DaliException e) {
69890       {
69891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69892       };
69893     } catch (...) {
69894       {
69895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69896       };
69897     }
69898   }
69899
69900 }
69901
69902
69903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69904   unsigned int jresult ;
69905   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69906   bool result;
69907
69908   arg1 = (Dali::Toolkit::Button *)jarg1;
69909   {
69910     try {
69911       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (Dali::DaliException e) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69927       };
69928     }
69929   }
69930
69931   jresult = result;
69932   return jresult;
69933 }
69934
69935
69936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69937   unsigned int jresult ;
69938   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69939   bool result;
69940
69941   arg1 = (Dali::Toolkit::Button *)jarg1;
69942   {
69943     try {
69944       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69945     } catch (std::out_of_range& e) {
69946       {
69947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69948       };
69949     } catch (std::exception& e) {
69950       {
69951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (Dali::DaliException e) {
69954       {
69955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69956       };
69957     } catch (...) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69960       };
69961     }
69962   }
69963
69964   jresult = result;
69965   return jresult;
69966 }
69967
69968
69969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69970   float jresult ;
69971   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69972   float result;
69973
69974   arg1 = (Dali::Toolkit::Button *)jarg1;
69975   {
69976     try {
69977       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69978     } catch (std::out_of_range& e) {
69979       {
69980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69981       };
69982     } catch (std::exception& e) {
69983       {
69984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69985       };
69986     } catch (Dali::DaliException e) {
69987       {
69988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69989       };
69990     } catch (...) {
69991       {
69992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69993       };
69994     }
69995   }
69996
69997   jresult = result;
69998   return jresult;
69999 }
70000
70001
70002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70003   float jresult ;
70004   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70005   float result;
70006
70007   arg1 = (Dali::Toolkit::Button *)jarg1;
70008   {
70009     try {
70010       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70011     } catch (std::out_of_range& e) {
70012       {
70013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (std::exception& e) {
70016       {
70017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (Dali::DaliException e) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70022       };
70023     } catch (...) {
70024       {
70025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70026       };
70027     }
70028   }
70029
70030   jresult = result;
70031   return jresult;
70032 }
70033
70034
70035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70036   unsigned int jresult ;
70037   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70038   bool result;
70039
70040   arg1 = (Dali::Toolkit::Button *)jarg1;
70041   {
70042     try {
70043       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70044     } catch (std::out_of_range& e) {
70045       {
70046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70047       };
70048     } catch (std::exception& e) {
70049       {
70050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (Dali::DaliException e) {
70053       {
70054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70055       };
70056     } catch (...) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70059       };
70060     }
70061   }
70062
70063   jresult = result;
70064   return jresult;
70065 }
70066
70067
70068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70069   unsigned int jresult ;
70070   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70071   bool result;
70072
70073   arg1 = (Dali::Toolkit::Button *)jarg1;
70074   {
70075     try {
70076       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (Dali::DaliException e) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70088       };
70089     } catch (...) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70092       };
70093     }
70094   }
70095
70096   jresult = result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70102   float jresult ;
70103   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70104   float result;
70105
70106   arg1 = (Dali::Toolkit::Button *)jarg1;
70107   {
70108     try {
70109       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (Dali::DaliException e) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70121       };
70122     } catch (...) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70125       };
70126     }
70127   }
70128
70129   jresult = result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70135   char * jresult ;
70136   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70137   std::string result;
70138
70139   arg1 = (Dali::Toolkit::Button *)jarg1;
70140   {
70141     try {
70142       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70143     } catch (std::out_of_range& e) {
70144       {
70145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (std::exception& e) {
70148       {
70149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70150       };
70151     } catch (Dali::DaliException e) {
70152       {
70153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70154       };
70155     } catch (...) {
70156       {
70157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70158       };
70159     }
70160   }
70161
70162   jresult = SWIG_csharp_string_callback((&result)->c_str());
70163   return jresult;
70164 }
70165
70166
70167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70168   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70169   Dali::Actor arg2 ;
70170   Dali::Actor *argp2 ;
70171
70172   arg1 = (Dali::Toolkit::Button *)jarg1;
70173   argp2 = (Dali::Actor *)jarg2;
70174   if (!argp2) {
70175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70176     return ;
70177   }
70178   arg2 = *argp2;
70179   {
70180     try {
70181       (arg1)->SetLabel(arg2);
70182     } catch (std::out_of_range& e) {
70183       {
70184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70185       };
70186     } catch (std::exception& e) {
70187       {
70188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70189       };
70190     } catch (Dali::DaliException e) {
70191       {
70192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70193       };
70194     } catch (...) {
70195       {
70196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70197       };
70198     }
70199   }
70200
70201 }
70202
70203
70204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70205   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70206   Dali::Image arg2 ;
70207   Dali::Image *argp2 ;
70208
70209   arg1 = (Dali::Toolkit::Button *)jarg1;
70210   argp2 = (Dali::Image *)jarg2;
70211   if (!argp2) {
70212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70213     return ;
70214   }
70215   arg2 = *argp2;
70216   {
70217     try {
70218       (arg1)->SetButtonImage(arg2);
70219     } catch (std::out_of_range& e) {
70220       {
70221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70222       };
70223     } catch (std::exception& e) {
70224       {
70225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70226       };
70227     } catch (Dali::DaliException e) {
70228       {
70229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70230       };
70231     } catch (...) {
70232       {
70233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70234       };
70235     }
70236   }
70237
70238 }
70239
70240
70241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70242   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70243   Dali::Image arg2 ;
70244   Dali::Image *argp2 ;
70245
70246   arg1 = (Dali::Toolkit::Button *)jarg1;
70247   argp2 = (Dali::Image *)jarg2;
70248   if (!argp2) {
70249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70250     return ;
70251   }
70252   arg2 = *argp2;
70253   {
70254     try {
70255       (arg1)->SetSelectedImage(arg2);
70256     } catch (std::out_of_range& e) {
70257       {
70258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70259       };
70260     } catch (std::exception& e) {
70261       {
70262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70263       };
70264     } catch (Dali::DaliException e) {
70265       {
70266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70267       };
70268     } catch (...) {
70269       {
70270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70271       };
70272     }
70273   }
70274
70275 }
70276
70277
70278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70279   void * jresult ;
70280   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70281   Dali::Actor result;
70282
70283   arg1 = (Dali::Toolkit::Button *)jarg1;
70284   {
70285     try {
70286       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70287     } catch (std::out_of_range& e) {
70288       {
70289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70290       };
70291     } catch (std::exception& e) {
70292       {
70293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70294       };
70295     } catch (Dali::DaliException e) {
70296       {
70297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70298       };
70299     } catch (...) {
70300       {
70301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70302       };
70303     }
70304   }
70305
70306   jresult = new Dali::Actor((const Dali::Actor &)result);
70307   return jresult;
70308 }
70309
70310
70311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70312   void * jresult ;
70313   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70314   Dali::Actor result;
70315
70316   arg1 = (Dali::Toolkit::Button *)jarg1;
70317   {
70318     try {
70319       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70320     } catch (std::out_of_range& e) {
70321       {
70322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70323       };
70324     } catch (std::exception& e) {
70325       {
70326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70327       };
70328     } catch (Dali::DaliException e) {
70329       {
70330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70331       };
70332     } catch (...) {
70333       {
70334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70335       };
70336     }
70337   }
70338
70339   jresult = new Dali::Actor((const Dali::Actor &)result);
70340   return jresult;
70341 }
70342
70343
70344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70345   void * jresult ;
70346   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70347   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70348
70349   arg1 = (Dali::Toolkit::Button *)jarg1;
70350   {
70351     try {
70352       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70353     } catch (std::out_of_range& e) {
70354       {
70355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70356       };
70357     } catch (std::exception& e) {
70358       {
70359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70360       };
70361     } catch (Dali::DaliException e) {
70362       {
70363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70364       };
70365     } catch (...) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70368       };
70369     }
70370   }
70371
70372   jresult = (void *)result;
70373   return jresult;
70374 }
70375
70376
70377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70378   void * jresult ;
70379   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70380   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70381
70382   arg1 = (Dali::Toolkit::Button *)jarg1;
70383   {
70384     try {
70385       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70386     } catch (std::out_of_range& e) {
70387       {
70388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70389       };
70390     } catch (std::exception& e) {
70391       {
70392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70393       };
70394     } catch (Dali::DaliException e) {
70395       {
70396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70397       };
70398     } catch (...) {
70399       {
70400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70401       };
70402     }
70403   }
70404
70405   jresult = (void *)result;
70406   return jresult;
70407 }
70408
70409
70410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70411   void * jresult ;
70412   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70413   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70414
70415   arg1 = (Dali::Toolkit::Button *)jarg1;
70416   {
70417     try {
70418       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70419     } catch (std::out_of_range& e) {
70420       {
70421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70422       };
70423     } catch (std::exception& e) {
70424       {
70425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (Dali::DaliException e) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70430       };
70431     } catch (...) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70434       };
70435     }
70436   }
70437
70438   jresult = (void *)result;
70439   return jresult;
70440 }
70441
70442
70443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70444   void * jresult ;
70445   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70446   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70447
70448   arg1 = (Dali::Toolkit::Button *)jarg1;
70449   {
70450     try {
70451       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70452     } catch (std::out_of_range& e) {
70453       {
70454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70455       };
70456     } catch (std::exception& e) {
70457       {
70458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70459       };
70460     } catch (Dali::DaliException e) {
70461       {
70462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70463       };
70464     } catch (...) {
70465       {
70466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70467       };
70468     }
70469   }
70470
70471   jresult = (void *)result;
70472   return jresult;
70473 }
70474
70475
70476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70477   void * jresult ;
70478   Dali::Toolkit::CheckBoxButton *result = 0 ;
70479
70480   {
70481     try {
70482       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (Dali::DaliException e) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70494       };
70495     } catch (...) {
70496       {
70497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70498       };
70499     }
70500   }
70501
70502   jresult = (void *)result;
70503   return jresult;
70504 }
70505
70506
70507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70508   void * jresult ;
70509   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70510   Dali::Toolkit::CheckBoxButton *result = 0 ;
70511
70512   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70513   if (!arg1) {
70514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70515     return 0;
70516   }
70517   {
70518     try {
70519       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70520     } catch (std::out_of_range& e) {
70521       {
70522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (std::exception& e) {
70525       {
70526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (Dali::DaliException e) {
70529       {
70530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70531       };
70532     } catch (...) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70535       };
70536     }
70537   }
70538
70539   jresult = (void *)result;
70540   return jresult;
70541 }
70542
70543
70544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70545   void * jresult ;
70546   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70547   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70548   Dali::Toolkit::CheckBoxButton *result = 0 ;
70549
70550   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70551   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70552   if (!arg2) {
70553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70554     return 0;
70555   }
70556   {
70557     try {
70558       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70559     } catch (std::out_of_range& e) {
70560       {
70561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70562       };
70563     } catch (std::exception& e) {
70564       {
70565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (Dali::DaliException e) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70570       };
70571     } catch (...) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70574       };
70575     }
70576   }
70577
70578   jresult = (void *)result;
70579   return jresult;
70580 }
70581
70582
70583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70584   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70585
70586   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70587   {
70588     try {
70589       delete arg1;
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70605       };
70606     }
70607   }
70608
70609 }
70610
70611
70612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70613   void * jresult ;
70614   Dali::Toolkit::CheckBoxButton result;
70615
70616   {
70617     try {
70618       result = Dali::Toolkit::CheckBoxButton::New();
70619     } catch (std::out_of_range& e) {
70620       {
70621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70622       };
70623     } catch (std::exception& e) {
70624       {
70625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70626       };
70627     } catch (Dali::DaliException e) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70630       };
70631     } catch (...) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70634       };
70635     }
70636   }
70637
70638   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70639   return jresult;
70640 }
70641
70642
70643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70644   void * jresult ;
70645   Dali::BaseHandle arg1 ;
70646   Dali::BaseHandle *argp1 ;
70647   Dali::Toolkit::CheckBoxButton result;
70648
70649   argp1 = (Dali::BaseHandle *)jarg1;
70650   if (!argp1) {
70651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70652     return 0;
70653   }
70654   arg1 = *argp1;
70655   {
70656     try {
70657       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70658     } catch (std::out_of_range& e) {
70659       {
70660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70661       };
70662     } catch (std::exception& e) {
70663       {
70664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (Dali::DaliException e) {
70667       {
70668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70669       };
70670     } catch (...) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70673       };
70674     }
70675   }
70676
70677   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70678   return jresult;
70679 }
70680
70681
70682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70683   int jresult ;
70684   int result;
70685
70686   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70687   jresult = (int)result;
70688   return jresult;
70689 }
70690
70691
70692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70693   int jresult ;
70694   int result;
70695
70696   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70697   jresult = (int)result;
70698   return jresult;
70699 }
70700
70701
70702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70703   int jresult ;
70704   int result;
70705
70706   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70707   jresult = (int)result;
70708   return jresult;
70709 }
70710
70711
70712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70713   int jresult ;
70714   int result;
70715
70716   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70717   jresult = (int)result;
70718   return jresult;
70719 }
70720
70721
70722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70723   int jresult ;
70724   int result;
70725
70726   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70727   jresult = (int)result;
70728   return jresult;
70729 }
70730
70731
70732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70733   void * jresult ;
70734   Dali::Toolkit::PushButton::Property *result = 0 ;
70735
70736   {
70737     try {
70738       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70739     } catch (std::out_of_range& e) {
70740       {
70741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70742       };
70743     } catch (std::exception& e) {
70744       {
70745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70746       };
70747     } catch (Dali::DaliException e) {
70748       {
70749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70750       };
70751     } catch (...) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70754       };
70755     }
70756   }
70757
70758   jresult = (void *)result;
70759   return jresult;
70760 }
70761
70762
70763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70764   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70765
70766   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70767   {
70768     try {
70769       delete arg1;
70770     } catch (std::out_of_range& e) {
70771       {
70772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70773       };
70774     } catch (std::exception& e) {
70775       {
70776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70777       };
70778     } catch (Dali::DaliException e) {
70779       {
70780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70781       };
70782     } catch (...) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70785       };
70786     }
70787   }
70788
70789 }
70790
70791
70792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70793   void * jresult ;
70794   Dali::Toolkit::PushButton *result = 0 ;
70795
70796   {
70797     try {
70798       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70799     } catch (std::out_of_range& e) {
70800       {
70801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70802       };
70803     } catch (std::exception& e) {
70804       {
70805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70806       };
70807     } catch (Dali::DaliException e) {
70808       {
70809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70810       };
70811     } catch (...) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70814       };
70815     }
70816   }
70817
70818   jresult = (void *)result;
70819   return jresult;
70820 }
70821
70822
70823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70824   void * jresult ;
70825   Dali::Toolkit::PushButton *arg1 = 0 ;
70826   Dali::Toolkit::PushButton *result = 0 ;
70827
70828   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70829   if (!arg1) {
70830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70831     return 0;
70832   }
70833   {
70834     try {
70835       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70843       };
70844     } catch (Dali::DaliException e) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70847       };
70848     } catch (...) {
70849       {
70850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70851       };
70852     }
70853   }
70854
70855   jresult = (void *)result;
70856   return jresult;
70857 }
70858
70859
70860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70861   void * jresult ;
70862   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70863   Dali::Toolkit::PushButton *arg2 = 0 ;
70864   Dali::Toolkit::PushButton *result = 0 ;
70865
70866   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70867   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70868   if (!arg2) {
70869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70870     return 0;
70871   }
70872   {
70873     try {
70874       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70875     } catch (std::out_of_range& e) {
70876       {
70877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (std::exception& e) {
70880       {
70881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70882       };
70883     } catch (Dali::DaliException e) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70890       };
70891     }
70892   }
70893
70894   jresult = (void *)result;
70895   return jresult;
70896 }
70897
70898
70899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70900   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70901
70902   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70903   {
70904     try {
70905       delete arg1;
70906     } catch (std::out_of_range& e) {
70907       {
70908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70909       };
70910     } catch (std::exception& e) {
70911       {
70912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70913       };
70914     } catch (Dali::DaliException e) {
70915       {
70916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70917       };
70918     } catch (...) {
70919       {
70920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70921       };
70922     }
70923   }
70924
70925 }
70926
70927
70928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70929   void * jresult ;
70930   Dali::Toolkit::PushButton result;
70931
70932   {
70933     try {
70934       result = Dali::Toolkit::PushButton::New();
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70960   void * jresult ;
70961   Dali::BaseHandle arg1 ;
70962   Dali::BaseHandle *argp1 ;
70963   Dali::Toolkit::PushButton result;
70964
70965   argp1 = (Dali::BaseHandle *)jarg1;
70966   if (!argp1) {
70967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70968     return 0;
70969   }
70970   arg1 = *argp1;
70971   {
70972     try {
70973       result = Dali::Toolkit::PushButton::DownCast(arg1);
70974     } catch (std::out_of_range& e) {
70975       {
70976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70977       };
70978     } catch (std::exception& e) {
70979       {
70980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70981       };
70982     } catch (Dali::DaliException e) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70985       };
70986     } catch (...) {
70987       {
70988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70989       };
70990     }
70991   }
70992
70993   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70994   return jresult;
70995 }
70996
70997
70998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70999   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71000   Dali::Image arg2 ;
71001   Dali::Image *argp2 ;
71002
71003   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71004   argp2 = (Dali::Image *)jarg2;
71005   if (!argp2) {
71006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71007     return ;
71008   }
71009   arg2 = *argp2;
71010   {
71011     try {
71012       (arg1)->SetButtonImage(arg2);
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71020       };
71021     } catch (Dali::DaliException e) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71028       };
71029     }
71030   }
71031
71032 }
71033
71034
71035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71036   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71037   Dali::Actor arg2 ;
71038   Dali::Actor *argp2 ;
71039
71040   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71041   argp2 = (Dali::Actor *)jarg2;
71042   if (!argp2) {
71043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71044     return ;
71045   }
71046   arg2 = *argp2;
71047   {
71048     try {
71049       (arg1)->SetButtonImage(arg2);
71050     } catch (std::out_of_range& e) {
71051       {
71052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71053       };
71054     } catch (std::exception& e) {
71055       {
71056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71057       };
71058     } catch (Dali::DaliException e) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71061       };
71062     } catch (...) {
71063       {
71064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71065       };
71066     }
71067   }
71068
71069 }
71070
71071
71072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71073   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71074   Dali::Actor arg2 ;
71075   Dali::Actor *argp2 ;
71076
71077   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71078   argp2 = (Dali::Actor *)jarg2;
71079   if (!argp2) {
71080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71081     return ;
71082   }
71083   arg2 = *argp2;
71084   {
71085     try {
71086       (arg1)->SetBackgroundImage(arg2);
71087     } catch (std::out_of_range& e) {
71088       {
71089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71090       };
71091     } catch (std::exception& e) {
71092       {
71093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71094       };
71095     } catch (Dali::DaliException e) {
71096       {
71097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71098       };
71099     } catch (...) {
71100       {
71101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71102       };
71103     }
71104   }
71105
71106 }
71107
71108
71109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71110   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71111   Dali::Image arg2 ;
71112   Dali::Image *argp2 ;
71113
71114   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71115   argp2 = (Dali::Image *)jarg2;
71116   if (!argp2) {
71117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71118     return ;
71119   }
71120   arg2 = *argp2;
71121   {
71122     try {
71123       (arg1)->SetSelectedImage(arg2);
71124     } catch (std::out_of_range& e) {
71125       {
71126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71127       };
71128     } catch (std::exception& e) {
71129       {
71130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71131       };
71132     } catch (Dali::DaliException e) {
71133       {
71134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71135       };
71136     } catch (...) {
71137       {
71138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71139       };
71140     }
71141   }
71142
71143 }
71144
71145
71146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71147   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71148   Dali::Actor arg2 ;
71149   Dali::Actor *argp2 ;
71150
71151   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71152   argp2 = (Dali::Actor *)jarg2;
71153   if (!argp2) {
71154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71155     return ;
71156   }
71157   arg2 = *argp2;
71158   {
71159     try {
71160       (arg1)->SetSelectedImage(arg2);
71161     } catch (std::out_of_range& e) {
71162       {
71163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71164       };
71165     } catch (std::exception& e) {
71166       {
71167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71168       };
71169     } catch (Dali::DaliException e) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71172       };
71173     } catch (...) {
71174       {
71175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71176       };
71177     }
71178   }
71179
71180 }
71181
71182
71183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71184   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71185   Dali::Actor arg2 ;
71186   Dali::Actor *argp2 ;
71187
71188   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71189   argp2 = (Dali::Actor *)jarg2;
71190   if (!argp2) {
71191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71192     return ;
71193   }
71194   arg2 = *argp2;
71195   {
71196     try {
71197       (arg1)->SetSelectedBackgroundImage(arg2);
71198     } catch (std::out_of_range& e) {
71199       {
71200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71201       };
71202     } catch (std::exception& e) {
71203       {
71204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71205       };
71206     } catch (Dali::DaliException e) {
71207       {
71208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71209       };
71210     } catch (...) {
71211       {
71212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71213       };
71214     }
71215   }
71216
71217 }
71218
71219
71220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71221   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71222   Dali::Actor arg2 ;
71223   Dali::Actor *argp2 ;
71224
71225   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71226   argp2 = (Dali::Actor *)jarg2;
71227   if (!argp2) {
71228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71229     return ;
71230   }
71231   arg2 = *argp2;
71232   {
71233     try {
71234       (arg1)->SetDisabledBackgroundImage(arg2);
71235     } catch (std::out_of_range& e) {
71236       {
71237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71238       };
71239     } catch (std::exception& e) {
71240       {
71241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71242       };
71243     } catch (Dali::DaliException e) {
71244       {
71245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71246       };
71247     } catch (...) {
71248       {
71249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71250       };
71251     }
71252   }
71253
71254 }
71255
71256
71257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71258   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71259   Dali::Actor arg2 ;
71260   Dali::Actor *argp2 ;
71261
71262   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71263   argp2 = (Dali::Actor *)jarg2;
71264   if (!argp2) {
71265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71266     return ;
71267   }
71268   arg2 = *argp2;
71269   {
71270     try {
71271       (arg1)->SetDisabledImage(arg2);
71272     } catch (std::out_of_range& e) {
71273       {
71274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71275       };
71276     } catch (std::exception& e) {
71277       {
71278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71279       };
71280     } catch (Dali::DaliException e) {
71281       {
71282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71283       };
71284     } catch (...) {
71285       {
71286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71287       };
71288     }
71289   }
71290
71291 }
71292
71293
71294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71295   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71296   Dali::Actor arg2 ;
71297   Dali::Actor *argp2 ;
71298
71299   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71300   argp2 = (Dali::Actor *)jarg2;
71301   if (!argp2) {
71302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71303     return ;
71304   }
71305   arg2 = *argp2;
71306   {
71307     try {
71308       (arg1)->SetDisabledSelectedImage(arg2);
71309     } catch (std::out_of_range& e) {
71310       {
71311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71312       };
71313     } catch (std::exception& e) {
71314       {
71315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71316       };
71317     } catch (Dali::DaliException e) {
71318       {
71319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71320       };
71321     } catch (...) {
71322       {
71323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71324       };
71325     }
71326   }
71327
71328 }
71329
71330
71331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71332   void * jresult ;
71333   Dali::Toolkit::RadioButton *result = 0 ;
71334
71335   {
71336     try {
71337       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71338     } catch (std::out_of_range& e) {
71339       {
71340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71341       };
71342     } catch (std::exception& e) {
71343       {
71344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71345       };
71346     } catch (Dali::DaliException e) {
71347       {
71348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71349       };
71350     } catch (...) {
71351       {
71352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71353       };
71354     }
71355   }
71356
71357   jresult = (void *)result;
71358   return jresult;
71359 }
71360
71361
71362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71363   void * jresult ;
71364   Dali::Toolkit::RadioButton *arg1 = 0 ;
71365   Dali::Toolkit::RadioButton *result = 0 ;
71366
71367   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71368   if (!arg1) {
71369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71370     return 0;
71371   }
71372   {
71373     try {
71374       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71375     } catch (std::out_of_range& e) {
71376       {
71377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71378       };
71379     } catch (std::exception& e) {
71380       {
71381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71382       };
71383     } catch (Dali::DaliException e) {
71384       {
71385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71386       };
71387     } catch (...) {
71388       {
71389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71390       };
71391     }
71392   }
71393
71394   jresult = (void *)result;
71395   return jresult;
71396 }
71397
71398
71399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71400   void * jresult ;
71401   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71402   Dali::Toolkit::RadioButton *arg2 = 0 ;
71403   Dali::Toolkit::RadioButton *result = 0 ;
71404
71405   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71406   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71407   if (!arg2) {
71408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71409     return 0;
71410   }
71411   {
71412     try {
71413       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71421       };
71422     } catch (Dali::DaliException e) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71425       };
71426     } catch (...) {
71427       {
71428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71429       };
71430     }
71431   }
71432
71433   jresult = (void *)result;
71434   return jresult;
71435 }
71436
71437
71438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71439   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71440
71441   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71442   {
71443     try {
71444       delete arg1;
71445     } catch (std::out_of_range& e) {
71446       {
71447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71448       };
71449     } catch (std::exception& e) {
71450       {
71451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (Dali::DaliException e) {
71454       {
71455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71460       };
71461     }
71462   }
71463
71464 }
71465
71466
71467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71468   void * jresult ;
71469   Dali::Toolkit::RadioButton result;
71470
71471   {
71472     try {
71473       result = Dali::Toolkit::RadioButton::New();
71474     } catch (std::out_of_range& e) {
71475       {
71476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71477       };
71478     } catch (std::exception& e) {
71479       {
71480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71481       };
71482     } catch (Dali::DaliException e) {
71483       {
71484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71485       };
71486     } catch (...) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71489       };
71490     }
71491   }
71492
71493   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71494   return jresult;
71495 }
71496
71497
71498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71499   void * jresult ;
71500   std::string *arg1 = 0 ;
71501   Dali::Toolkit::RadioButton result;
71502
71503   if (!jarg1) {
71504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71505     return 0;
71506   }
71507   std::string arg1_str(jarg1);
71508   arg1 = &arg1_str;
71509   {
71510     try {
71511       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71512     } catch (std::out_of_range& e) {
71513       {
71514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71515       };
71516     } catch (std::exception& e) {
71517       {
71518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71519       };
71520     } catch (Dali::DaliException e) {
71521       {
71522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71523       };
71524     } catch (...) {
71525       {
71526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71527       };
71528     }
71529   }
71530
71531   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71532
71533   //argout typemap for const std::string&
71534
71535   return jresult;
71536 }
71537
71538
71539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71540   void * jresult ;
71541   Dali::BaseHandle arg1 ;
71542   Dali::BaseHandle *argp1 ;
71543   Dali::Toolkit::RadioButton result;
71544
71545   argp1 = (Dali::BaseHandle *)jarg1;
71546   if (!argp1) {
71547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71548     return 0;
71549   }
71550   arg1 = *argp1;
71551   {
71552     try {
71553       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71554     } catch (std::out_of_range& e) {
71555       {
71556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71557       };
71558     } catch (std::exception& e) {
71559       {
71560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71561       };
71562     } catch (Dali::DaliException e) {
71563       {
71564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71565       };
71566     } catch (...) {
71567       {
71568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71569       };
71570     }
71571   }
71572
71573   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71574   return jresult;
71575 }
71576
71577
71578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71579   int jresult ;
71580   int result;
71581
71582   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71583   jresult = (int)result;
71584   return jresult;
71585 }
71586
71587
71588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71589   int jresult ;
71590   int result;
71591
71592   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71593   jresult = (int)result;
71594   return jresult;
71595 }
71596
71597
71598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71599   int jresult ;
71600   int result;
71601
71602   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71603   jresult = (int)result;
71604   return jresult;
71605 }
71606
71607
71608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71609   int jresult ;
71610   int result;
71611
71612   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71613   jresult = (int)result;
71614   return jresult;
71615 }
71616
71617
71618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71619   int jresult ;
71620   int result;
71621
71622   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71623   jresult = (int)result;
71624   return jresult;
71625 }
71626
71627
71628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71629   int jresult ;
71630   int result;
71631
71632   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71633   jresult = (int)result;
71634   return jresult;
71635 }
71636
71637
71638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71639   void * jresult ;
71640   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71641
71642   {
71643     try {
71644       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71645     } catch (std::out_of_range& e) {
71646       {
71647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71648       };
71649     } catch (std::exception& e) {
71650       {
71651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71652       };
71653     } catch (Dali::DaliException e) {
71654       {
71655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71656       };
71657     } catch (...) {
71658       {
71659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71660       };
71661     }
71662   }
71663
71664   jresult = (void *)result;
71665   return jresult;
71666 }
71667
71668
71669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71670   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71671
71672   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71673   {
71674     try {
71675       delete arg1;
71676     } catch (std::out_of_range& e) {
71677       {
71678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71679       };
71680     } catch (std::exception& e) {
71681       {
71682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71683       };
71684     } catch (Dali::DaliException e) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71687       };
71688     } catch (...) {
71689       {
71690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71691       };
71692     }
71693   }
71694
71695 }
71696
71697
71698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71699   int jresult ;
71700   int result;
71701
71702   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71703   jresult = (int)result;
71704   return jresult;
71705 }
71706
71707
71708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71709   int jresult ;
71710   int result;
71711
71712   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71713   jresult = (int)result;
71714   return jresult;
71715 }
71716
71717
71718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71719   int jresult ;
71720   int result;
71721
71722   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71723   jresult = (int)result;
71724   return jresult;
71725 }
71726
71727
71728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71729   void * jresult ;
71730   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71731
71732   {
71733     try {
71734       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71735     } catch (std::out_of_range& e) {
71736       {
71737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71738       };
71739     } catch (std::exception& e) {
71740       {
71741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71742       };
71743     } catch (Dali::DaliException e) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71746       };
71747     } catch (...) {
71748       {
71749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71750       };
71751     }
71752   }
71753
71754   jresult = (void *)result;
71755   return jresult;
71756 }
71757
71758
71759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71760   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71761
71762   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71763   {
71764     try {
71765       delete arg1;
71766     } catch (std::out_of_range& e) {
71767       {
71768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71769       };
71770     } catch (std::exception& e) {
71771       {
71772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71773       };
71774     } catch (Dali::DaliException e) {
71775       {
71776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71777       };
71778     } catch (...) {
71779       {
71780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71781       };
71782     }
71783   }
71784
71785 }
71786
71787
71788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71789   void * jresult ;
71790   Dali::Toolkit::FlexContainer *result = 0 ;
71791
71792   {
71793     try {
71794       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71795     } catch (std::out_of_range& e) {
71796       {
71797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71798       };
71799     } catch (std::exception& e) {
71800       {
71801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (Dali::DaliException e) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71806       };
71807     } catch (...) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71810       };
71811     }
71812   }
71813
71814   jresult = (void *)result;
71815   return jresult;
71816 }
71817
71818
71819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71820   void * jresult ;
71821   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71822   Dali::Toolkit::FlexContainer *result = 0 ;
71823
71824   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71825   if (!arg1) {
71826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71827     return 0;
71828   }
71829   {
71830     try {
71831       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71832     } catch (std::out_of_range& e) {
71833       {
71834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71835       };
71836     } catch (std::exception& e) {
71837       {
71838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71839       };
71840     } catch (Dali::DaliException e) {
71841       {
71842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71843       };
71844     } catch (...) {
71845       {
71846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71847       };
71848     }
71849   }
71850
71851   jresult = (void *)result;
71852   return jresult;
71853 }
71854
71855
71856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71857   void * jresult ;
71858   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71859   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71860   Dali::Toolkit::FlexContainer *result = 0 ;
71861
71862   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71863   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71864   if (!arg2) {
71865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71866     return 0;
71867   }
71868   {
71869     try {
71870       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71878       };
71879     } catch (Dali::DaliException e) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71882       };
71883     } catch (...) {
71884       {
71885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71886       };
71887     }
71888   }
71889
71890   jresult = (void *)result;
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71896   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71897
71898   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71899   {
71900     try {
71901       delete arg1;
71902     } catch (std::out_of_range& e) {
71903       {
71904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71905       };
71906     } catch (std::exception& e) {
71907       {
71908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71909       };
71910     } catch (Dali::DaliException e) {
71911       {
71912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71913       };
71914     } catch (...) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71917       };
71918     }
71919   }
71920
71921 }
71922
71923
71924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71925   void * jresult ;
71926   Dali::Toolkit::FlexContainer result;
71927
71928   {
71929     try {
71930       result = Dali::Toolkit::FlexContainer::New();
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71956   void * jresult ;
71957   Dali::BaseHandle arg1 ;
71958   Dali::BaseHandle *argp1 ;
71959   Dali::Toolkit::FlexContainer result;
71960
71961   argp1 = (Dali::BaseHandle *)jarg1;
71962   if (!argp1) {
71963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71964     return 0;
71965   }
71966   arg1 = *argp1;
71967   {
71968     try {
71969       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71970     } catch (std::out_of_range& e) {
71971       {
71972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71973       };
71974     } catch (std::exception& e) {
71975       {
71976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71977       };
71978     } catch (Dali::DaliException e) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71981       };
71982     } catch (...) {
71983       {
71984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71985       };
71986     }
71987   }
71988
71989   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71990   return jresult;
71991 }
71992
71993
71994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71995   int jresult ;
71996   int result;
71997
71998   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71999   jresult = (int)result;
72000   return jresult;
72001 }
72002
72003
72004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72005   int jresult ;
72006   int result;
72007
72008   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72009   jresult = (int)result;
72010   return jresult;
72011 }
72012
72013
72014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72015   int jresult ;
72016   int result;
72017
72018   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72019   jresult = (int)result;
72020   return jresult;
72021 }
72022
72023
72024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72025   int jresult ;
72026   int result;
72027
72028   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72029   jresult = (int)result;
72030   return jresult;
72031 }
72032
72033
72034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72035   void * jresult ;
72036   Dali::Toolkit::ImageView::Property *result = 0 ;
72037
72038   {
72039     try {
72040       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72041     } catch (std::out_of_range& e) {
72042       {
72043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72044       };
72045     } catch (std::exception& e) {
72046       {
72047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (Dali::DaliException e) {
72050       {
72051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72056       };
72057     }
72058   }
72059
72060   jresult = (void *)result;
72061   return jresult;
72062 }
72063
72064
72065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72066   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72067
72068   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72069   {
72070     try {
72071       delete arg1;
72072     } catch (std::out_of_range& e) {
72073       {
72074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72075       };
72076     } catch (std::exception& e) {
72077       {
72078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72079       };
72080     } catch (Dali::DaliException e) {
72081       {
72082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72083       };
72084     } catch (...) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72087       };
72088     }
72089   }
72090
72091 }
72092
72093
72094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72095   void * jresult ;
72096   Dali::Toolkit::ImageView *result = 0 ;
72097
72098   {
72099     try {
72100       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72101     } catch (std::out_of_range& e) {
72102       {
72103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (std::exception& e) {
72106       {
72107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72108       };
72109     } catch (Dali::DaliException e) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72112       };
72113     } catch (...) {
72114       {
72115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72116       };
72117     }
72118   }
72119
72120   jresult = (void *)result;
72121   return jresult;
72122 }
72123
72124
72125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72126   void * jresult ;
72127   Dali::Toolkit::ImageView result;
72128
72129   {
72130     try {
72131       result = Dali::Toolkit::ImageView::New();
72132     } catch (std::out_of_range& e) {
72133       {
72134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72135       };
72136     } catch (std::exception& e) {
72137       {
72138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72139       };
72140     } catch (Dali::DaliException e) {
72141       {
72142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72143       };
72144     } catch (...) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72147       };
72148     }
72149   }
72150
72151   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72152   return jresult;
72153 }
72154
72155
72156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72157   void * jresult ;
72158   Dali::Image arg1 ;
72159   Dali::Image *argp1 ;
72160   Dali::Toolkit::ImageView result;
72161
72162   argp1 = (Dali::Image *)jarg1;
72163   if (!argp1) {
72164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72165     return 0;
72166   }
72167   arg1 = *argp1;
72168   {
72169     try {
72170       result = Dali::Toolkit::ImageView::New(arg1);
72171     } catch (std::out_of_range& e) {
72172       {
72173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72174       };
72175     } catch (std::exception& e) {
72176       {
72177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72178       };
72179     } catch (Dali::DaliException e) {
72180       {
72181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72182       };
72183     } catch (...) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72186       };
72187     }
72188   }
72189
72190   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72191   return jresult;
72192 }
72193
72194
72195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72196   void * jresult ;
72197   std::string *arg1 = 0 ;
72198   Dali::Toolkit::ImageView result;
72199
72200   if (!jarg1) {
72201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72202     return 0;
72203   }
72204   std::string arg1_str(jarg1);
72205   arg1 = &arg1_str;
72206   {
72207     try {
72208       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72209     } catch (std::out_of_range& e) {
72210       {
72211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72212       };
72213     } catch (std::exception& e) {
72214       {
72215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72216       };
72217     } catch (Dali::DaliException e) {
72218       {
72219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72220       };
72221     } catch (...) {
72222       {
72223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72224       };
72225     }
72226   }
72227
72228   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72229
72230   //argout typemap for const std::string&
72231
72232   return jresult;
72233 }
72234
72235
72236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72237   void * jresult ;
72238   std::string *arg1 = 0 ;
72239   Dali::ImageDimensions arg2 ;
72240   Dali::ImageDimensions *argp2 ;
72241   Dali::Toolkit::ImageView result;
72242
72243   if (!jarg1) {
72244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72245     return 0;
72246   }
72247   std::string arg1_str(jarg1);
72248   arg1 = &arg1_str;
72249   argp2 = (Dali::ImageDimensions *)jarg2;
72250   if (!argp2) {
72251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72252     return 0;
72253   }
72254   arg2 = *argp2;
72255   {
72256     try {
72257       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72258     } catch (std::out_of_range& e) {
72259       {
72260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72261       };
72262     } catch (std::exception& e) {
72263       {
72264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72265       };
72266     } catch (Dali::DaliException e) {
72267       {
72268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72269       };
72270     } catch (...) {
72271       {
72272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72273       };
72274     }
72275   }
72276
72277   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72278
72279   //argout typemap for const std::string&
72280
72281   return jresult;
72282 }
72283
72284
72285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72286   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72287
72288   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72289   {
72290     try {
72291       delete arg1;
72292     } catch (std::out_of_range& e) {
72293       {
72294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72295       };
72296     } catch (std::exception& e) {
72297       {
72298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72299       };
72300     } catch (Dali::DaliException e) {
72301       {
72302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72303       };
72304     } catch (...) {
72305       {
72306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72307       };
72308     }
72309   }
72310
72311 }
72312
72313
72314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72315   void * jresult ;
72316   Dali::Toolkit::ImageView *arg1 = 0 ;
72317   Dali::Toolkit::ImageView *result = 0 ;
72318
72319   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72320   if (!arg1) {
72321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72322     return 0;
72323   }
72324   {
72325     try {
72326       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72327     } catch (std::out_of_range& e) {
72328       {
72329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72330       };
72331     } catch (std::exception& e) {
72332       {
72333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72334       };
72335     } catch (Dali::DaliException e) {
72336       {
72337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72338       };
72339     } catch (...) {
72340       {
72341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72342       };
72343     }
72344   }
72345
72346   jresult = (void *)result;
72347   return jresult;
72348 }
72349
72350
72351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72352   void * jresult ;
72353   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72354   Dali::Toolkit::ImageView *arg2 = 0 ;
72355   Dali::Toolkit::ImageView *result = 0 ;
72356
72357   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72358   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72359   if (!arg2) {
72360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72361     return 0;
72362   }
72363   {
72364     try {
72365       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72366     } catch (std::out_of_range& e) {
72367       {
72368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72369       };
72370     } catch (std::exception& e) {
72371       {
72372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72373       };
72374     } catch (Dali::DaliException e) {
72375       {
72376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72377       };
72378     } catch (...) {
72379       {
72380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72381       };
72382     }
72383   }
72384
72385   jresult = (void *)result;
72386   return jresult;
72387 }
72388
72389
72390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72391   void * jresult ;
72392   Dali::BaseHandle arg1 ;
72393   Dali::BaseHandle *argp1 ;
72394   Dali::Toolkit::ImageView result;
72395
72396   argp1 = (Dali::BaseHandle *)jarg1;
72397   if (!argp1) {
72398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72399     return 0;
72400   }
72401   arg1 = *argp1;
72402   {
72403     try {
72404       result = Dali::Toolkit::ImageView::DownCast(arg1);
72405     } catch (std::out_of_range& e) {
72406       {
72407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72408       };
72409     } catch (std::exception& e) {
72410       {
72411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72412       };
72413     } catch (Dali::DaliException e) {
72414       {
72415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72416       };
72417     } catch (...) {
72418       {
72419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72420       };
72421     }
72422   }
72423
72424   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72425   return jresult;
72426 }
72427
72428
72429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72430   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72431   Dali::Image arg2 ;
72432   Dali::Image *argp2 ;
72433
72434   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72435   argp2 = (Dali::Image *)jarg2;
72436   if (!argp2) {
72437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72438     return ;
72439   }
72440   arg2 = *argp2;
72441   {
72442     try {
72443       (arg1)->SetImage(arg2);
72444     } catch (std::out_of_range& e) {
72445       {
72446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72447       };
72448     } catch (std::exception& e) {
72449       {
72450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72451       };
72452     } catch (Dali::DaliException e) {
72453       {
72454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72455       };
72456     } catch (...) {
72457       {
72458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72459       };
72460     }
72461   }
72462
72463 }
72464
72465
72466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72467   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72468   std::string *arg2 = 0 ;
72469
72470   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72471   if (!jarg2) {
72472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72473     return ;
72474   }
72475   std::string arg2_str(jarg2);
72476   arg2 = &arg2_str;
72477   {
72478     try {
72479       (arg1)->SetImage((std::string const &)*arg2);
72480     } catch (std::out_of_range& e) {
72481       {
72482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72483       };
72484     } catch (std::exception& e) {
72485       {
72486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72487       };
72488     } catch (Dali::DaliException e) {
72489       {
72490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72491       };
72492     } catch (...) {
72493       {
72494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72495       };
72496     }
72497   }
72498
72499
72500   //argout typemap for const std::string&
72501
72502 }
72503
72504
72505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72506   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72507   std::string *arg2 = 0 ;
72508   Dali::ImageDimensions arg3 ;
72509   Dali::ImageDimensions *argp3 ;
72510
72511   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72512   if (!jarg2) {
72513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72514     return ;
72515   }
72516   std::string arg2_str(jarg2);
72517   arg2 = &arg2_str;
72518   argp3 = (Dali::ImageDimensions *)jarg3;
72519   if (!argp3) {
72520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72521     return ;
72522   }
72523   arg3 = *argp3;
72524   {
72525     try {
72526       (arg1)->SetImage((std::string const &)*arg2,arg3);
72527     } catch (std::out_of_range& e) {
72528       {
72529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72530       };
72531     } catch (std::exception& e) {
72532       {
72533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72534       };
72535     } catch (Dali::DaliException e) {
72536       {
72537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72538       };
72539     } catch (...) {
72540       {
72541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72542       };
72543     }
72544   }
72545
72546
72547   //argout typemap for const std::string&
72548
72549 }
72550
72551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72552   void * jresult ;
72553   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72554   Dali::Image result;
72555
72556   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72557   {
72558     try {
72559       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72560     } catch (std::out_of_range& e) {
72561       {
72562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72563       };
72564     } catch (std::exception& e) {
72565       {
72566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72567       };
72568     } catch (Dali::DaliException e) {
72569       {
72570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72571       };
72572     } catch (...) {
72573       {
72574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72575       };
72576     }
72577   }
72578
72579   jresult = new Dali::Image((const Dali::Image &)result);
72580   return jresult;
72581 }
72582
72583
72584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72585   int jresult ;
72586   int result;
72587
72588   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72589   jresult = (int)result;
72590   return jresult;
72591 }
72592
72593
72594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72595   int jresult ;
72596   int result;
72597
72598   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72599   jresult = (int)result;
72600   return jresult;
72601 }
72602
72603
72604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72605   int jresult ;
72606   int result;
72607
72608   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72609   jresult = (int)result;
72610   return jresult;
72611 }
72612
72613
72614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72615   int jresult ;
72616   int result;
72617
72618   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72619   jresult = (int)result;
72620   return jresult;
72621 }
72622
72623
72624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72625   int jresult ;
72626   int result;
72627
72628   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72629   jresult = (int)result;
72630   return jresult;
72631 }
72632
72633
72634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72635   int jresult ;
72636   int result;
72637
72638   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72639   jresult = (int)result;
72640   return jresult;
72641 }
72642
72643
72644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72645   int jresult ;
72646   int result;
72647
72648   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72649   jresult = (int)result;
72650   return jresult;
72651 }
72652
72653
72654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72655   int jresult ;
72656   int result;
72657
72658   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72659   jresult = (int)result;
72660   return jresult;
72661 }
72662
72663
72664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72665   void * jresult ;
72666   Dali::Toolkit::Model3dView::Property *result = 0 ;
72667
72668   {
72669     try {
72670       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72671     } catch (std::out_of_range& e) {
72672       {
72673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72674       };
72675     } catch (std::exception& e) {
72676       {
72677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72678       };
72679     } catch (Dali::DaliException e) {
72680       {
72681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72682       };
72683     } catch (...) {
72684       {
72685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72686       };
72687     }
72688   }
72689
72690   jresult = (void *)result;
72691   return jresult;
72692 }
72693
72694
72695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72696   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72697
72698   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72699   {
72700     try {
72701       delete arg1;
72702     } catch (std::out_of_range& e) {
72703       {
72704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72705       };
72706     } catch (std::exception& e) {
72707       {
72708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72709       };
72710     } catch (Dali::DaliException e) {
72711       {
72712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72713       };
72714     } catch (...) {
72715       {
72716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72717       };
72718     }
72719   }
72720
72721 }
72722
72723
72724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72725   void * jresult ;
72726   Dali::Toolkit::Model3dView result;
72727
72728   {
72729     try {
72730       result = Dali::Toolkit::Model3dView::New();
72731     } catch (std::out_of_range& e) {
72732       {
72733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72734       };
72735     } catch (std::exception& e) {
72736       {
72737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72738       };
72739     } catch (Dali::DaliException e) {
72740       {
72741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72742       };
72743     } catch (...) {
72744       {
72745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72746       };
72747     }
72748   }
72749
72750   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72751   return jresult;
72752 }
72753
72754
72755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72756   void * jresult ;
72757   std::string *arg1 = 0 ;
72758   std::string *arg2 = 0 ;
72759   std::string *arg3 = 0 ;
72760   Dali::Toolkit::Model3dView result;
72761
72762   if (!jarg1) {
72763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72764     return 0;
72765   }
72766   std::string arg1_str(jarg1);
72767   arg1 = &arg1_str;
72768   if (!jarg2) {
72769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72770     return 0;
72771   }
72772   std::string arg2_str(jarg2);
72773   arg2 = &arg2_str;
72774   if (!jarg3) {
72775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72776     return 0;
72777   }
72778   std::string arg3_str(jarg3);
72779   arg3 = &arg3_str;
72780   {
72781     try {
72782       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72783     } catch (std::out_of_range& e) {
72784       {
72785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72786       };
72787     } catch (std::exception& e) {
72788       {
72789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72790       };
72791     } catch (Dali::DaliException e) {
72792       {
72793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72794       };
72795     } catch (...) {
72796       {
72797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72798       };
72799     }
72800   }
72801
72802   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72803
72804   //argout typemap for const std::string&
72805
72806
72807   //argout typemap for const std::string&
72808
72809
72810   //argout typemap for const std::string&
72811
72812   return jresult;
72813 }
72814
72815
72816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72817   void * jresult ;
72818   Dali::Toolkit::Model3dView *result = 0 ;
72819
72820   {
72821     try {
72822       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72823     } catch (std::out_of_range& e) {
72824       {
72825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72826       };
72827     } catch (std::exception& e) {
72828       {
72829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (Dali::DaliException e) {
72832       {
72833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72834       };
72835     } catch (...) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72838       };
72839     }
72840   }
72841
72842   jresult = (void *)result;
72843   return jresult;
72844 }
72845
72846
72847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72848   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72849
72850   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72851   {
72852     try {
72853       delete arg1;
72854     } catch (std::out_of_range& e) {
72855       {
72856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72857       };
72858     } catch (std::exception& e) {
72859       {
72860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72861       };
72862     } catch (Dali::DaliException e) {
72863       {
72864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72865       };
72866     } catch (...) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72869       };
72870     }
72871   }
72872
72873 }
72874
72875
72876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72877   void * jresult ;
72878   Dali::Toolkit::Model3dView *arg1 = 0 ;
72879   Dali::Toolkit::Model3dView *result = 0 ;
72880
72881   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72882   if (!arg1) {
72883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72884     return 0;
72885   }
72886   {
72887     try {
72888       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72889     } catch (std::out_of_range& e) {
72890       {
72891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72892       };
72893     } catch (std::exception& e) {
72894       {
72895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (Dali::DaliException e) {
72898       {
72899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72900       };
72901     } catch (...) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72904       };
72905     }
72906   }
72907
72908   jresult = (void *)result;
72909   return jresult;
72910 }
72911
72912
72913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72914   void * jresult ;
72915   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72916   Dali::Toolkit::Model3dView *arg2 = 0 ;
72917   Dali::Toolkit::Model3dView *result = 0 ;
72918
72919   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72920   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72921   if (!arg2) {
72922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72923     return 0;
72924   }
72925   {
72926     try {
72927       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72928     } catch (std::out_of_range& e) {
72929       {
72930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72931       };
72932     } catch (std::exception& e) {
72933       {
72934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72935       };
72936     } catch (Dali::DaliException e) {
72937       {
72938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72939       };
72940     } catch (...) {
72941       {
72942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72943       };
72944     }
72945   }
72946
72947   jresult = (void *)result;
72948   return jresult;
72949 }
72950
72951
72952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72953   void * jresult ;
72954   Dali::BaseHandle arg1 ;
72955   Dali::BaseHandle *argp1 ;
72956   Dali::Toolkit::Model3dView result;
72957
72958   argp1 = (Dali::BaseHandle *)jarg1;
72959   if (!argp1) {
72960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72961     return 0;
72962   }
72963   arg1 = *argp1;
72964   {
72965     try {
72966       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (Dali::DaliException e) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72982       };
72983     }
72984   }
72985
72986   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72992   int jresult ;
72993   int result;
72994
72995   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72996   jresult = (int)result;
72997   return jresult;
72998 }
72999
73000
73001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73002   int jresult ;
73003   int result;
73004
73005   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73006   jresult = (int)result;
73007   return jresult;
73008 }
73009
73010
73011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73012   int jresult ;
73013   int result;
73014
73015   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73016   jresult = (int)result;
73017   return jresult;
73018 }
73019
73020
73021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73022   int jresult ;
73023   int result;
73024
73025   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73026   jresult = (int)result;
73027   return jresult;
73028 }
73029
73030
73031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73032   int jresult ;
73033   int result;
73034
73035   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73036   jresult = (int)result;
73037   return jresult;
73038 }
73039
73040
73041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73042   int jresult ;
73043   int result;
73044
73045   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73046   jresult = (int)result;
73047   return jresult;
73048 }
73049
73050
73051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73052   int jresult ;
73053   int result;
73054
73055   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73056   jresult = (int)result;
73057   return jresult;
73058 }
73059
73060
73061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73062   int jresult ;
73063   int result;
73064
73065   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73066   jresult = (int)result;
73067   return jresult;
73068 }
73069
73070
73071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73072   int jresult ;
73073   int result;
73074
73075   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73076   jresult = (int)result;
73077   return jresult;
73078 }
73079
73080
73081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73082   void * jresult ;
73083   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73084
73085   {
73086     try {
73087       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73088     } catch (std::out_of_range& e) {
73089       {
73090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73091       };
73092     } catch (std::exception& e) {
73093       {
73094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73095       };
73096     } catch (Dali::DaliException e) {
73097       {
73098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73099       };
73100     } catch (...) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73103       };
73104     }
73105   }
73106
73107   jresult = (void *)result;
73108   return jresult;
73109 }
73110
73111
73112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73113   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73114
73115   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73116   {
73117     try {
73118       delete arg1;
73119     } catch (std::out_of_range& e) {
73120       {
73121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73122       };
73123     } catch (std::exception& e) {
73124       {
73125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73126       };
73127     } catch (Dali::DaliException e) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73130       };
73131     } catch (...) {
73132       {
73133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73134       };
73135     }
73136   }
73137
73138 }
73139
73140
73141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73142   void * jresult ;
73143   Dali::Toolkit::ScrollBar *result = 0 ;
73144
73145   {
73146     try {
73147       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73148     } catch (std::out_of_range& e) {
73149       {
73150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73151       };
73152     } catch (std::exception& e) {
73153       {
73154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73155       };
73156     } catch (Dali::DaliException e) {
73157       {
73158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73159       };
73160     } catch (...) {
73161       {
73162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73163       };
73164     }
73165   }
73166
73167   jresult = (void *)result;
73168   return jresult;
73169 }
73170
73171
73172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73173   void * jresult ;
73174   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73175   Dali::Toolkit::ScrollBar *result = 0 ;
73176
73177   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73178   if (!arg1) {
73179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73180     return 0;
73181   }
73182   {
73183     try {
73184       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73185     } catch (std::out_of_range& e) {
73186       {
73187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73188       };
73189     } catch (std::exception& e) {
73190       {
73191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (Dali::DaliException e) {
73194       {
73195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73196       };
73197     } catch (...) {
73198       {
73199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73200       };
73201     }
73202   }
73203
73204   jresult = (void *)result;
73205   return jresult;
73206 }
73207
73208
73209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73210   void * jresult ;
73211   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73212   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73213   Dali::Toolkit::ScrollBar *result = 0 ;
73214
73215   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73216   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73217   if (!arg2) {
73218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73219     return 0;
73220   }
73221   {
73222     try {
73223       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (Dali::DaliException e) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73239       };
73240     }
73241   }
73242
73243   jresult = (void *)result;
73244   return jresult;
73245 }
73246
73247
73248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73249   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73250
73251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73252   {
73253     try {
73254       delete arg1;
73255     } catch (std::out_of_range& e) {
73256       {
73257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73258       };
73259     } catch (std::exception& e) {
73260       {
73261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73262       };
73263     } catch (Dali::DaliException e) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73270       };
73271     }
73272   }
73273
73274 }
73275
73276
73277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73278   void * jresult ;
73279   Dali::Toolkit::ScrollBar::Direction arg1 ;
73280   Dali::Toolkit::ScrollBar result;
73281
73282   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73283   {
73284     try {
73285       result = Dali::Toolkit::ScrollBar::New(arg1);
73286     } catch (std::out_of_range& e) {
73287       {
73288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73289       };
73290     } catch (std::exception& e) {
73291       {
73292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73293       };
73294     } catch (Dali::DaliException e) {
73295       {
73296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73297       };
73298     } catch (...) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73301       };
73302     }
73303   }
73304
73305   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73306   return jresult;
73307 }
73308
73309
73310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73311   void * jresult ;
73312   Dali::Toolkit::ScrollBar result;
73313
73314   {
73315     try {
73316       result = Dali::Toolkit::ScrollBar::New();
73317     } catch (std::out_of_range& e) {
73318       {
73319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73320       };
73321     } catch (std::exception& e) {
73322       {
73323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (Dali::DaliException e) {
73326       {
73327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73328       };
73329     } catch (...) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73332       };
73333     }
73334   }
73335
73336   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73337   return jresult;
73338 }
73339
73340
73341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73342   void * jresult ;
73343   Dali::BaseHandle arg1 ;
73344   Dali::BaseHandle *argp1 ;
73345   Dali::Toolkit::ScrollBar result;
73346
73347   argp1 = (Dali::BaseHandle *)jarg1;
73348   if (!argp1) {
73349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73350     return 0;
73351   }
73352   arg1 = *argp1;
73353   {
73354     try {
73355       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (Dali::DaliException e) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73367       };
73368     } catch (...) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73371       };
73372     }
73373   }
73374
73375   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73376   return jresult;
73377 }
73378
73379
73380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73381   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73382   Dali::Handle arg2 ;
73383   Dali::Property::Index arg3 ;
73384   Dali::Property::Index arg4 ;
73385   Dali::Property::Index arg5 ;
73386   Dali::Property::Index arg6 ;
73387   Dali::Handle *argp2 ;
73388
73389   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73390   argp2 = (Dali::Handle *)jarg2;
73391   if (!argp2) {
73392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73393     return ;
73394   }
73395   arg2 = *argp2;
73396   arg3 = (Dali::Property::Index)jarg3;
73397   arg4 = (Dali::Property::Index)jarg4;
73398   arg5 = (Dali::Property::Index)jarg5;
73399   arg6 = (Dali::Property::Index)jarg6;
73400   {
73401     try {
73402       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73410       };
73411     } catch (Dali::DaliException e) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73414       };
73415     } catch (...) {
73416       {
73417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73418       };
73419     }
73420   }
73421
73422 }
73423
73424
73425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73426   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73427   Dali::Actor arg2 ;
73428   Dali::Actor *argp2 ;
73429
73430   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73431   argp2 = (Dali::Actor *)jarg2;
73432   if (!argp2) {
73433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73434     return ;
73435   }
73436   arg2 = *argp2;
73437   {
73438     try {
73439       (arg1)->SetScrollIndicator(arg2);
73440     } catch (std::out_of_range& e) {
73441       {
73442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73443       };
73444     } catch (std::exception& e) {
73445       {
73446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73447       };
73448     } catch (Dali::DaliException e) {
73449       {
73450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73451       };
73452     } catch (...) {
73453       {
73454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73455       };
73456     }
73457   }
73458
73459 }
73460
73461
73462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73463   void * jresult ;
73464   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73465   Dali::Actor result;
73466
73467   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73468   {
73469     try {
73470       result = (arg1)->GetScrollIndicator();
73471     } catch (std::out_of_range& e) {
73472       {
73473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73474       };
73475     } catch (std::exception& e) {
73476       {
73477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73478       };
73479     } catch (Dali::DaliException e) {
73480       {
73481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73482       };
73483     } catch (...) {
73484       {
73485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73486       };
73487     }
73488   }
73489
73490   jresult = new Dali::Actor((const Dali::Actor &)result);
73491   return jresult;
73492 }
73493
73494
73495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73496   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73497   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73498
73499   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73500   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73501   if (!arg2) {
73502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73503     return ;
73504   }
73505   {
73506     try {
73507       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73508     } catch (std::out_of_range& e) {
73509       {
73510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73511       };
73512     } catch (std::exception& e) {
73513       {
73514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73515       };
73516     } catch (Dali::DaliException e) {
73517       {
73518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73519       };
73520     } catch (...) {
73521       {
73522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73523       };
73524     }
73525   }
73526
73527 }
73528
73529
73530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73531   void * jresult ;
73532   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73533
73534   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73535   {
73536     try {
73537       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()));
73538     } catch (std::out_of_range& e) {
73539       {
73540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73541       };
73542     } catch (std::exception& e) {
73543       {
73544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73545       };
73546     } catch (...) {
73547       {
73548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73549       };
73550     }
73551   }
73552   return jresult;
73553 }
73554
73555
73556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73557   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73558   Dali::Toolkit::ScrollBar::Direction arg2 ;
73559
73560   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73561   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73562   {
73563     try {
73564       (arg1)->SetScrollDirection(arg2);
73565     } catch (std::out_of_range& e) {
73566       {
73567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73568       };
73569     } catch (std::exception& e) {
73570       {
73571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73572       };
73573     } catch (Dali::DaliException e) {
73574       {
73575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73576       };
73577     } catch (...) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73580       };
73581     }
73582   }
73583
73584 }
73585
73586
73587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73588   int jresult ;
73589   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73590   Dali::Toolkit::ScrollBar::Direction result;
73591
73592   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73593   {
73594     try {
73595       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73596     } catch (std::out_of_range& e) {
73597       {
73598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73599       };
73600     } catch (std::exception& e) {
73601       {
73602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73603       };
73604     } catch (Dali::DaliException e) {
73605       {
73606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73607       };
73608     } catch (...) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73611       };
73612     }
73613   }
73614
73615   jresult = (int)result;
73616   return jresult;
73617 }
73618
73619
73620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73621   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73622   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73623
73624   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73625   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73626   {
73627     try {
73628       (arg1)->SetIndicatorHeightPolicy(arg2);
73629     } catch (std::out_of_range& e) {
73630       {
73631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73632       };
73633     } catch (std::exception& e) {
73634       {
73635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73636       };
73637     } catch (Dali::DaliException e) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73640       };
73641     } catch (...) {
73642       {
73643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73644       };
73645     }
73646   }
73647
73648 }
73649
73650
73651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73652   int jresult ;
73653   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73654   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73655
73656   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73657   {
73658     try {
73659       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73660     } catch (std::out_of_range& e) {
73661       {
73662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73663       };
73664     } catch (std::exception& e) {
73665       {
73666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73667       };
73668     } catch (Dali::DaliException e) {
73669       {
73670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73671       };
73672     } catch (...) {
73673       {
73674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73675       };
73676     }
73677   }
73678
73679   jresult = (int)result;
73680   return jresult;
73681 }
73682
73683
73684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73685   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73686   float arg2 ;
73687
73688   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73689   arg2 = (float)jarg2;
73690   {
73691     try {
73692       (arg1)->SetIndicatorFixedHeight(arg2);
73693     } catch (std::out_of_range& e) {
73694       {
73695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73696       };
73697     } catch (std::exception& e) {
73698       {
73699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73700       };
73701     } catch (Dali::DaliException e) {
73702       {
73703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73704       };
73705     } catch (...) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73708       };
73709     }
73710   }
73711
73712 }
73713
73714
73715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73716   float jresult ;
73717   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73718   float result;
73719
73720   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73721   {
73722     try {
73723       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73724     } catch (std::out_of_range& e) {
73725       {
73726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73727       };
73728     } catch (std::exception& e) {
73729       {
73730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73731       };
73732     } catch (Dali::DaliException e) {
73733       {
73734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73735       };
73736     } catch (...) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73739       };
73740     }
73741   }
73742
73743   jresult = result;
73744   return jresult;
73745 }
73746
73747
73748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73749   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73750   float arg2 ;
73751
73752   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73753   arg2 = (float)jarg2;
73754   {
73755     try {
73756       (arg1)->SetIndicatorShowDuration(arg2);
73757     } catch (std::out_of_range& e) {
73758       {
73759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73760       };
73761     } catch (std::exception& e) {
73762       {
73763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73764       };
73765     } catch (Dali::DaliException e) {
73766       {
73767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73768       };
73769     } catch (...) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73772       };
73773     }
73774   }
73775
73776 }
73777
73778
73779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73780   float jresult ;
73781   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73782   float result;
73783
73784   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73785   {
73786     try {
73787       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73788     } catch (std::out_of_range& e) {
73789       {
73790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73791       };
73792     } catch (std::exception& e) {
73793       {
73794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73795       };
73796     } catch (Dali::DaliException e) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73803       };
73804     }
73805   }
73806
73807   jresult = result;
73808   return jresult;
73809 }
73810
73811
73812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73813   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73814   float arg2 ;
73815
73816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73817   arg2 = (float)jarg2;
73818   {
73819     try {
73820       (arg1)->SetIndicatorHideDuration(arg2);
73821     } catch (std::out_of_range& e) {
73822       {
73823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73824       };
73825     } catch (std::exception& e) {
73826       {
73827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73828       };
73829     } catch (Dali::DaliException e) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73832       };
73833     } catch (...) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73836       };
73837     }
73838   }
73839
73840 }
73841
73842
73843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73844   float jresult ;
73845   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73846   float result;
73847
73848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73849   {
73850     try {
73851       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73852     } catch (std::out_of_range& e) {
73853       {
73854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (std::exception& e) {
73857       {
73858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (Dali::DaliException e) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73867       };
73868     }
73869   }
73870
73871   jresult = result;
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73878
73879   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73880   {
73881     try {
73882       (arg1)->ShowIndicator();
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73890       };
73891     } catch (Dali::DaliException e) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73894       };
73895     } catch (...) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73898       };
73899     }
73900   }
73901
73902 }
73903
73904
73905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73906   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73907
73908   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73909   {
73910     try {
73911       (arg1)->HideIndicator();
73912     } catch (std::out_of_range& e) {
73913       {
73914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73915       };
73916     } catch (std::exception& e) {
73917       {
73918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73919       };
73920     } catch (Dali::DaliException e) {
73921       {
73922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73923       };
73924     } catch (...) {
73925       {
73926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73927       };
73928     }
73929   }
73930
73931 }
73932
73933
73934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73935   void * jresult ;
73936   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73937   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73938
73939   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73940   {
73941     try {
73942       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73943     } catch (std::out_of_range& e) {
73944       {
73945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73946       };
73947     } catch (std::exception& e) {
73948       {
73949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73950       };
73951     } catch (Dali::DaliException e) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73954       };
73955     } catch (...) {
73956       {
73957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73958       };
73959     }
73960   }
73961
73962   jresult = (void *)result;
73963   return jresult;
73964 }
73965
73966
73967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73968   void * jresult ;
73969   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73970   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73971
73972   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73973   {
73974     try {
73975       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73983       };
73984     } catch (Dali::DaliException e) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73987       };
73988     } catch (...) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73991       };
73992     }
73993   }
73994
73995   jresult = (void *)result;
73996   return jresult;
73997 }
73998
73999
74000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74001   int jresult ;
74002   int result;
74003
74004   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74005   jresult = (int)result;
74006   return jresult;
74007 }
74008
74009
74010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74011   int jresult ;
74012   int result;
74013
74014   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74015   jresult = (int)result;
74016   return jresult;
74017 }
74018
74019
74020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74021   int jresult ;
74022   int result;
74023
74024   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74025   jresult = (int)result;
74026   return jresult;
74027 }
74028
74029
74030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74031   int jresult ;
74032   int result;
74033
74034   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74035   jresult = (int)result;
74036   return jresult;
74037 }
74038
74039
74040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74041   int jresult ;
74042   int result;
74043
74044   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74045   jresult = (int)result;
74046   return jresult;
74047 }
74048
74049
74050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74051   int jresult ;
74052   int result;
74053
74054   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74055   jresult = (int)result;
74056   return jresult;
74057 }
74058
74059
74060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74061   int jresult ;
74062   int result;
74063
74064   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74065   jresult = (int)result;
74066   return jresult;
74067 }
74068
74069
74070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74071   int jresult ;
74072   int result;
74073
74074   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74075   jresult = (int)result;
74076   return jresult;
74077 }
74078
74079
74080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74081   int jresult ;
74082   int result;
74083
74084   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74085   jresult = (int)result;
74086   return jresult;
74087 }
74088
74089
74090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74091   int jresult ;
74092   int result;
74093
74094   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74095   jresult = (int)result;
74096   return jresult;
74097 }
74098
74099
74100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74101   int jresult ;
74102   int result;
74103
74104   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74105   jresult = (int)result;
74106   return jresult;
74107 }
74108
74109
74110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74111   int jresult ;
74112   int result;
74113
74114   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74115   jresult = (int)result;
74116   return jresult;
74117 }
74118
74119
74120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74121   int jresult ;
74122   int result;
74123
74124   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74125   jresult = (int)result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74131   int jresult ;
74132   int result;
74133
74134   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74135   jresult = (int)result;
74136   return jresult;
74137 }
74138
74139
74140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74141   void * jresult ;
74142   Dali::Toolkit::Scrollable::Property *result = 0 ;
74143
74144   {
74145     try {
74146       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74147     } catch (std::out_of_range& e) {
74148       {
74149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74150       };
74151     } catch (std::exception& e) {
74152       {
74153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (Dali::DaliException e) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74158       };
74159     } catch (...) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74162       };
74163     }
74164   }
74165
74166   jresult = (void *)result;
74167   return jresult;
74168 }
74169
74170
74171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74172   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74173
74174   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74175   {
74176     try {
74177       delete arg1;
74178     } catch (std::out_of_range& e) {
74179       {
74180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74181       };
74182     } catch (std::exception& e) {
74183       {
74184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74185       };
74186     } catch (Dali::DaliException e) {
74187       {
74188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74189       };
74190     } catch (...) {
74191       {
74192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74193       };
74194     }
74195   }
74196
74197 }
74198
74199
74200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74201   void * jresult ;
74202   Dali::Toolkit::Scrollable *result = 0 ;
74203
74204   {
74205     try {
74206       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74207     } catch (std::out_of_range& e) {
74208       {
74209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74210       };
74211     } catch (std::exception& e) {
74212       {
74213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74214       };
74215     } catch (Dali::DaliException e) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74218       };
74219     } catch (...) {
74220       {
74221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74222       };
74223     }
74224   }
74225
74226   jresult = (void *)result;
74227   return jresult;
74228 }
74229
74230
74231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74232   void * jresult ;
74233   Dali::Toolkit::Scrollable *arg1 = 0 ;
74234   Dali::Toolkit::Scrollable *result = 0 ;
74235
74236   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74237   if (!arg1) {
74238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74239     return 0;
74240   }
74241   {
74242     try {
74243       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74244     } catch (std::out_of_range& e) {
74245       {
74246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74247       };
74248     } catch (std::exception& e) {
74249       {
74250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74251       };
74252     } catch (Dali::DaliException e) {
74253       {
74254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74255       };
74256     } catch (...) {
74257       {
74258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74259       };
74260     }
74261   }
74262
74263   jresult = (void *)result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74269   void * jresult ;
74270   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74271   Dali::Toolkit::Scrollable *arg2 = 0 ;
74272   Dali::Toolkit::Scrollable *result = 0 ;
74273
74274   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74275   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74276   if (!arg2) {
74277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74278     return 0;
74279   }
74280   {
74281     try {
74282       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74283     } catch (std::out_of_range& e) {
74284       {
74285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (std::exception& e) {
74288       {
74289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74290       };
74291     } catch (Dali::DaliException e) {
74292       {
74293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74294       };
74295     } catch (...) {
74296       {
74297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74298       };
74299     }
74300   }
74301
74302   jresult = (void *)result;
74303   return jresult;
74304 }
74305
74306
74307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74308   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74309
74310   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74311   {
74312     try {
74313       delete arg1;
74314     } catch (std::out_of_range& e) {
74315       {
74316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74317       };
74318     } catch (std::exception& e) {
74319       {
74320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74321       };
74322     } catch (Dali::DaliException e) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74325       };
74326     } catch (...) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74329       };
74330     }
74331   }
74332
74333 }
74334
74335
74336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74337   void * jresult ;
74338   Dali::BaseHandle arg1 ;
74339   Dali::BaseHandle *argp1 ;
74340   Dali::Toolkit::Scrollable result;
74341
74342   argp1 = (Dali::BaseHandle *)jarg1;
74343   if (!argp1) {
74344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74345     return 0;
74346   }
74347   arg1 = *argp1;
74348   {
74349     try {
74350       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74351     } catch (std::out_of_range& e) {
74352       {
74353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74354       };
74355     } catch (std::exception& e) {
74356       {
74357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74358       };
74359     } catch (Dali::DaliException e) {
74360       {
74361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74362       };
74363     } catch (...) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74366       };
74367     }
74368   }
74369
74370   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74371   return jresult;
74372 }
74373
74374
74375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74376   unsigned int jresult ;
74377   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74378   bool result;
74379
74380   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74381   {
74382     try {
74383       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74384     } catch (std::out_of_range& e) {
74385       {
74386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74387       };
74388     } catch (std::exception& e) {
74389       {
74390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (Dali::DaliException e) {
74393       {
74394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74395       };
74396     } catch (...) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74399       };
74400     }
74401   }
74402
74403   jresult = result;
74404   return jresult;
74405 }
74406
74407
74408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74409   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74410   bool arg2 ;
74411
74412   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74413   arg2 = jarg2 ? true : false;
74414   {
74415     try {
74416       (arg1)->SetOvershootEnabled(arg2);
74417     } catch (std::out_of_range& e) {
74418       {
74419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74420       };
74421     } catch (std::exception& e) {
74422       {
74423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (Dali::DaliException e) {
74426       {
74427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74432       };
74433     }
74434   }
74435
74436 }
74437
74438
74439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74440   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74441   Dali::Vector4 *arg2 = 0 ;
74442
74443   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74444   arg2 = (Dali::Vector4 *)jarg2;
74445   if (!arg2) {
74446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74447     return ;
74448   }
74449   {
74450     try {
74451       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74452     } catch (std::out_of_range& e) {
74453       {
74454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74455       };
74456     } catch (std::exception& e) {
74457       {
74458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74459       };
74460     } catch (Dali::DaliException e) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74463       };
74464     } catch (...) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74467       };
74468     }
74469   }
74470
74471 }
74472
74473
74474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74475   void * jresult ;
74476   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74477   Dali::Vector4 result;
74478
74479   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74480   {
74481     try {
74482       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74483     } catch (std::out_of_range& e) {
74484       {
74485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (std::exception& e) {
74488       {
74489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (Dali::DaliException e) {
74492       {
74493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74494       };
74495     } catch (...) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74498       };
74499     }
74500   }
74501
74502   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74508   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74509   float arg2 ;
74510
74511   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74512   arg2 = (float)jarg2;
74513   {
74514     try {
74515       (arg1)->SetOvershootAnimationSpeed(arg2);
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74523       };
74524     } catch (Dali::DaliException e) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74527       };
74528     } catch (...) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74531       };
74532     }
74533   }
74534
74535 }
74536
74537
74538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74539   float jresult ;
74540   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74541   float result;
74542
74543   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74544   {
74545     try {
74546       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (Dali::DaliException e) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74558       };
74559     } catch (...) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74562       };
74563     }
74564   }
74565
74566   jresult = result;
74567   return jresult;
74568 }
74569
74570
74571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74572   void * jresult ;
74573   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74574   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74575
74576   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74577   {
74578     try {
74579       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74580     } catch (std::out_of_range& e) {
74581       {
74582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74583       };
74584     } catch (std::exception& e) {
74585       {
74586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74587       };
74588     } catch (Dali::DaliException e) {
74589       {
74590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74591       };
74592     } catch (...) {
74593       {
74594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74595       };
74596     }
74597   }
74598
74599   jresult = (void *)result;
74600   return jresult;
74601 }
74602
74603
74604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74605   void * jresult ;
74606   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74607   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74608
74609   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74610   {
74611     try {
74612       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74613     } catch (std::out_of_range& e) {
74614       {
74615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74616       };
74617     } catch (std::exception& e) {
74618       {
74619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74620       };
74621     } catch (Dali::DaliException e) {
74622       {
74623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74624       };
74625     } catch (...) {
74626       {
74627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74628       };
74629     }
74630   }
74631
74632   jresult = (void *)result;
74633   return jresult;
74634 }
74635
74636
74637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74638   void * jresult ;
74639   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74640   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74641
74642   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74643   {
74644     try {
74645       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74646     } catch (std::out_of_range& e) {
74647       {
74648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74649       };
74650     } catch (std::exception& e) {
74651       {
74652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74653       };
74654     } catch (Dali::DaliException e) {
74655       {
74656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74657       };
74658     } catch (...) {
74659       {
74660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74661       };
74662     }
74663   }
74664
74665   jresult = (void *)result;
74666   return jresult;
74667 }
74668
74669
74670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74671   unsigned int jresult ;
74672   Dali::Toolkit::ControlOrientation::Type arg1 ;
74673   bool result;
74674
74675   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74676   {
74677     try {
74678       result = (bool)Dali::Toolkit::IsVertical(arg1);
74679     } catch (std::out_of_range& e) {
74680       {
74681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74682       };
74683     } catch (std::exception& e) {
74684       {
74685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74686       };
74687     } catch (Dali::DaliException e) {
74688       {
74689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74690       };
74691     } catch (...) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74694       };
74695     }
74696   }
74697
74698   jresult = result;
74699   return jresult;
74700 }
74701
74702
74703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74704   unsigned int jresult ;
74705   Dali::Toolkit::ControlOrientation::Type arg1 ;
74706   bool result;
74707
74708   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74709   {
74710     try {
74711       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74712     } catch (std::out_of_range& e) {
74713       {
74714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74715       };
74716     } catch (std::exception& e) {
74717       {
74718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74719       };
74720     } catch (Dali::DaliException e) {
74721       {
74722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74723       };
74724     } catch (...) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74727       };
74728     }
74729   }
74730
74731   jresult = result;
74732   return jresult;
74733 }
74734
74735
74736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74737   void * jresult ;
74738   unsigned int arg1 ;
74739   unsigned int arg2 ;
74740   Dali::Toolkit::ItemRange *result = 0 ;
74741
74742   arg1 = (unsigned int)jarg1;
74743   arg2 = (unsigned int)jarg2;
74744   {
74745     try {
74746       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74747     } catch (std::out_of_range& e) {
74748       {
74749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74750       };
74751     } catch (std::exception& e) {
74752       {
74753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74754       };
74755     } catch (Dali::DaliException e) {
74756       {
74757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74758       };
74759     } catch (...) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74762       };
74763     }
74764   }
74765
74766   jresult = (void *)result;
74767   return jresult;
74768 }
74769
74770
74771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74772   void * jresult ;
74773   Dali::Toolkit::ItemRange *arg1 = 0 ;
74774   Dali::Toolkit::ItemRange *result = 0 ;
74775
74776   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74777   if (!arg1) {
74778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74779     return 0;
74780   }
74781   {
74782     try {
74783       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74784     } catch (std::out_of_range& e) {
74785       {
74786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74787       };
74788     } catch (std::exception& e) {
74789       {
74790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74791       };
74792     } catch (Dali::DaliException e) {
74793       {
74794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74795       };
74796     } catch (...) {
74797       {
74798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74799       };
74800     }
74801   }
74802
74803   jresult = (void *)result;
74804   return jresult;
74805 }
74806
74807
74808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74809   void * jresult ;
74810   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74811   Dali::Toolkit::ItemRange *arg2 = 0 ;
74812   Dali::Toolkit::ItemRange *result = 0 ;
74813
74814   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74815   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74816   if (!arg2) {
74817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74818     return 0;
74819   }
74820   {
74821     try {
74822       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74823     } catch (std::out_of_range& e) {
74824       {
74825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74826       };
74827     } catch (std::exception& e) {
74828       {
74829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74830       };
74831     } catch (Dali::DaliException e) {
74832       {
74833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74834       };
74835     } catch (...) {
74836       {
74837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74838       };
74839     }
74840   }
74841
74842   jresult = (void *)result;
74843   return jresult;
74844 }
74845
74846
74847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74848   unsigned int jresult ;
74849   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74850   unsigned int arg2 ;
74851   bool result;
74852
74853   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74854   arg2 = (unsigned int)jarg2;
74855   {
74856     try {
74857       result = (bool)(arg1)->Within(arg2);
74858     } catch (std::out_of_range& e) {
74859       {
74860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74861       };
74862     } catch (std::exception& e) {
74863       {
74864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74865       };
74866     } catch (Dali::DaliException e) {
74867       {
74868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74869       };
74870     } catch (...) {
74871       {
74872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74873       };
74874     }
74875   }
74876
74877   jresult = result;
74878   return jresult;
74879 }
74880
74881
74882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74883   void * jresult ;
74884   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74885   Dali::Toolkit::ItemRange *arg2 = 0 ;
74886   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74887
74888   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74889   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74890   if (!arg2) {
74891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74892     return 0;
74893   }
74894   {
74895     try {
74896       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74897     } catch (std::out_of_range& e) {
74898       {
74899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74900       };
74901     } catch (std::exception& e) {
74902       {
74903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74904       };
74905     } catch (Dali::DaliException e) {
74906       {
74907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74908       };
74909     } catch (...) {
74910       {
74911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74912       };
74913     }
74914   }
74915
74916   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74917   return jresult;
74918 }
74919
74920
74921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74922   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74923   unsigned int arg2 ;
74924
74925   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74926   arg2 = (unsigned int)jarg2;
74927   if (arg1) (arg1)->begin = arg2;
74928 }
74929
74930
74931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74932   unsigned int jresult ;
74933   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74934   unsigned int result;
74935
74936   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74937   result = (unsigned int) ((arg1)->begin);
74938   jresult = result;
74939   return jresult;
74940 }
74941
74942
74943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74944   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74945   unsigned int arg2 ;
74946
74947   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74948   arg2 = (unsigned int)jarg2;
74949   if (arg1) (arg1)->end = arg2;
74950 }
74951
74952
74953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74954   unsigned int jresult ;
74955   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74956   unsigned int result;
74957
74958   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74959   result = (unsigned int) ((arg1)->end);
74960   jresult = result;
74961   return jresult;
74962 }
74963
74964
74965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74966   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74967
74968   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74969   {
74970     try {
74971       delete arg1;
74972     } catch (std::out_of_range& e) {
74973       {
74974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74975       };
74976     } catch (std::exception& e) {
74977       {
74978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74979       };
74980     } catch (Dali::DaliException e) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74983       };
74984     } catch (...) {
74985       {
74986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74987       };
74988     }
74989   }
74990
74991 }
74992
74993
74994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74995   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74996
74997   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74998   {
74999     try {
75000       delete arg1;
75001     } catch (std::out_of_range& e) {
75002       {
75003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75004       };
75005     } catch (std::exception& e) {
75006       {
75007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75008       };
75009     } catch (Dali::DaliException e) {
75010       {
75011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75012       };
75013     } catch (...) {
75014       {
75015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75016       };
75017     }
75018   }
75019
75020 }
75021
75022
75023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75024   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75025   Dali::Toolkit::ControlOrientation::Type arg2 ;
75026
75027   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75028   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75029   {
75030     try {
75031       (arg1)->SetOrientation(arg2);
75032     } catch (std::out_of_range& e) {
75033       {
75034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75035       };
75036     } catch (std::exception& e) {
75037       {
75038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75039       };
75040     } catch (Dali::DaliException e) {
75041       {
75042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75043       };
75044     } catch (...) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75047       };
75048     }
75049   }
75050
75051 }
75052
75053
75054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75055   int jresult ;
75056   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75057   Dali::Toolkit::ControlOrientation::Type result;
75058
75059   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75060   {
75061     try {
75062       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75063     } catch (std::out_of_range& e) {
75064       {
75065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75066       };
75067     } catch (std::exception& e) {
75068       {
75069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (Dali::DaliException e) {
75072       {
75073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75074       };
75075     } catch (...) {
75076       {
75077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75078       };
75079     }
75080   }
75081
75082   jresult = (int)result;
75083   return jresult;
75084 }
75085
75086
75087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75088   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75089   Dali::Property::Map *arg2 = 0 ;
75090
75091   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75092   arg2 = (Dali::Property::Map *)jarg2;
75093   if (!arg2) {
75094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75095     return ;
75096   }
75097   {
75098     try {
75099       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75100     } catch (std::out_of_range& e) {
75101       {
75102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75103       };
75104     } catch (std::exception& e) {
75105       {
75106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75107       };
75108     } catch (Dali::DaliException e) {
75109       {
75110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75111       };
75112     } catch (...) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75115       };
75116     }
75117   }
75118
75119 }
75120
75121
75122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75123   void * jresult ;
75124   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75125   Dali::Property::Map result;
75126
75127   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75128   {
75129     try {
75130       result = (arg1)->GetLayoutProperties();
75131     } catch (std::out_of_range& e) {
75132       {
75133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75134       };
75135     } catch (std::exception& e) {
75136       {
75137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75138       };
75139     } catch (Dali::DaliException e) {
75140       {
75141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75142       };
75143     } catch (...) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75146       };
75147     }
75148   }
75149
75150   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75151   return jresult;
75152 }
75153
75154
75155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75156   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75157   unsigned int arg2 ;
75158   Dali::Vector3 *arg3 = 0 ;
75159   Dali::Vector3 *arg4 = 0 ;
75160
75161   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75162   arg2 = (unsigned int)jarg2;
75163   arg3 = (Dali::Vector3 *)jarg3;
75164   if (!arg3) {
75165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75166     return ;
75167   }
75168   arg4 = (Dali::Vector3 *)jarg4;
75169   if (!arg4) {
75170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75171     return ;
75172   }
75173   {
75174     try {
75175       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75176     } catch (std::out_of_range& e) {
75177       {
75178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75179       };
75180     } catch (std::exception& e) {
75181       {
75182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75183       };
75184     } catch (Dali::DaliException e) {
75185       {
75186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75187       };
75188     } catch (...) {
75189       {
75190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75191       };
75192     }
75193   }
75194
75195 }
75196
75197
75198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75199   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75200   Dali::Vector3 *arg2 = 0 ;
75201
75202   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75203   arg2 = (Dali::Vector3 *)jarg2;
75204   if (!arg2) {
75205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75206     return ;
75207   }
75208   {
75209     try {
75210       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75226       };
75227     }
75228   }
75229
75230 }
75231
75232
75233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75234   float jresult ;
75235   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75236   unsigned int arg2 ;
75237   Dali::Vector3 arg3 ;
75238   Dali::Vector3 *argp3 ;
75239   float result;
75240
75241   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75242   arg2 = (unsigned int)jarg2;
75243   argp3 = (Dali::Vector3 *)jarg3;
75244   if (!argp3) {
75245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75246     return 0;
75247   }
75248   arg3 = *argp3;
75249   {
75250     try {
75251       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75252     } catch (std::out_of_range& e) {
75253       {
75254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75255       };
75256     } catch (std::exception& e) {
75257       {
75258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75259       };
75260     } catch (Dali::DaliException e) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75263       };
75264     } catch (...) {
75265       {
75266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75267       };
75268     }
75269   }
75270
75271   jresult = result;
75272   return jresult;
75273 }
75274
75275
75276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75277   float jresult ;
75278   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75279   float arg2 ;
75280   float result;
75281
75282   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75283   arg2 = (float)jarg2;
75284   {
75285     try {
75286       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75287     } catch (std::out_of_range& e) {
75288       {
75289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75290       };
75291     } catch (std::exception& e) {
75292       {
75293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (Dali::DaliException e) {
75296       {
75297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75298       };
75299     } catch (...) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75302       };
75303     }
75304   }
75305
75306   jresult = result;
75307   return jresult;
75308 }
75309
75310
75311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75312   float jresult ;
75313   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75314   unsigned int arg2 ;
75315   float result;
75316
75317   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75318   arg2 = (unsigned int)jarg2;
75319   {
75320     try {
75321       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75322     } catch (std::out_of_range& e) {
75323       {
75324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75325       };
75326     } catch (std::exception& e) {
75327       {
75328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75329       };
75330     } catch (Dali::DaliException e) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75337       };
75338     }
75339   }
75340
75341   jresult = result;
75342   return jresult;
75343 }
75344
75345
75346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75347   void * jresult ;
75348   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75349   float arg2 ;
75350   Dali::Vector3 arg3 ;
75351   Dali::Vector3 *argp3 ;
75352   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75353
75354   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75355   arg2 = (float)jarg2;
75356   argp3 = (Dali::Vector3 *)jarg3;
75357   if (!argp3) {
75358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75359     return 0;
75360   }
75361   arg3 = *argp3;
75362   {
75363     try {
75364       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75365     } catch (std::out_of_range& e) {
75366       {
75367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75368       };
75369     } catch (std::exception& e) {
75370       {
75371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75372       };
75373     } catch (Dali::DaliException e) {
75374       {
75375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75376       };
75377     } catch (...) {
75378       {
75379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75380       };
75381     }
75382   }
75383
75384   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75385   return jresult;
75386 }
75387
75388
75389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75390   float jresult ;
75391   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75392   int arg2 ;
75393   float arg3 ;
75394   Dali::Vector3 *arg4 = 0 ;
75395   float result;
75396
75397   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75398   arg2 = (int)jarg2;
75399   arg3 = (float)jarg3;
75400   arg4 = (Dali::Vector3 *)jarg4;
75401   if (!arg4) {
75402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75403     return 0;
75404   }
75405   {
75406     try {
75407       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75408     } catch (std::out_of_range& e) {
75409       {
75410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75411       };
75412     } catch (std::exception& e) {
75413       {
75414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75415       };
75416     } catch (Dali::DaliException e) {
75417       {
75418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75419       };
75420     } catch (...) {
75421       {
75422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75423       };
75424     }
75425   }
75426
75427   jresult = result;
75428   return jresult;
75429 }
75430
75431
75432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75433   unsigned int jresult ;
75434   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75435   Dali::Vector3 arg2 ;
75436   Dali::Vector3 *argp2 ;
75437   unsigned int result;
75438
75439   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75440   argp2 = (Dali::Vector3 *)jarg2;
75441   if (!argp2) {
75442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75443     return 0;
75444   }
75445   arg2 = *argp2;
75446   {
75447     try {
75448       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75474   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75475   unsigned int arg2 ;
75476   Dali::Vector3 *arg3 = 0 ;
75477   Dali::Vector3 *arg4 = 0 ;
75478
75479   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75480   arg2 = (unsigned int)jarg2;
75481   arg3 = (Dali::Vector3 *)jarg3;
75482   if (!arg3) {
75483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75484     return ;
75485   }
75486   arg4 = (Dali::Vector3 *)jarg4;
75487   if (!arg4) {
75488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75489     return ;
75490   }
75491   {
75492     try {
75493       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75494     } catch (std::out_of_range& e) {
75495       {
75496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75497       };
75498     } catch (std::exception& e) {
75499       {
75500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75501       };
75502     } catch (Dali::DaliException e) {
75503       {
75504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75505       };
75506     } catch (...) {
75507       {
75508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75509       };
75510     }
75511   }
75512
75513 }
75514
75515
75516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75517   void * jresult ;
75518   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75519   Dali::Degree result;
75520
75521   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75522   {
75523     try {
75524       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75525     } catch (std::out_of_range& e) {
75526       {
75527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75528       };
75529     } catch (std::exception& e) {
75530       {
75531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75532       };
75533     } catch (Dali::DaliException e) {
75534       {
75535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75536       };
75537     } catch (...) {
75538       {
75539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75540       };
75541     }
75542   }
75543
75544   jresult = new Dali::Degree((const Dali::Degree &)result);
75545   return jresult;
75546 }
75547
75548
75549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75550   float jresult ;
75551   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75552   float result;
75553
75554   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75555   {
75556     try {
75557       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75558     } catch (std::out_of_range& e) {
75559       {
75560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75561       };
75562     } catch (std::exception& e) {
75563       {
75564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75565       };
75566     } catch (Dali::DaliException e) {
75567       {
75568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75569       };
75570     } catch (...) {
75571       {
75572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75573       };
75574     }
75575   }
75576
75577   jresult = result;
75578   return jresult;
75579 }
75580
75581
75582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75583   float jresult ;
75584   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75585   float result;
75586
75587   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75588   {
75589     try {
75590       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75591     } catch (std::out_of_range& e) {
75592       {
75593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75594       };
75595     } catch (std::exception& e) {
75596       {
75597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75598       };
75599     } catch (Dali::DaliException e) {
75600       {
75601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75602       };
75603     } catch (...) {
75604       {
75605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75606       };
75607     }
75608   }
75609
75610   jresult = result;
75611   return jresult;
75612 }
75613
75614
75615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75616   float jresult ;
75617   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75618   float result;
75619
75620   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75621   {
75622     try {
75623       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75624     } catch (std::out_of_range& e) {
75625       {
75626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75627       };
75628     } catch (std::exception& e) {
75629       {
75630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75631       };
75632     } catch (Dali::DaliException e) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75635       };
75636     } catch (...) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75639       };
75640     }
75641   }
75642
75643   jresult = result;
75644   return jresult;
75645 }
75646
75647
75648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75649   int jresult ;
75650   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75651   int arg2 ;
75652   int arg3 ;
75653   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75654   bool arg5 ;
75655   int result;
75656
75657   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75658   arg2 = (int)jarg2;
75659   arg3 = (int)jarg3;
75660   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75661   arg5 = jarg5 ? true : false;
75662   {
75663     try {
75664       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75665     } catch (std::out_of_range& e) {
75666       {
75667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75668       };
75669     } catch (std::exception& e) {
75670       {
75671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75672       };
75673     } catch (Dali::DaliException e) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75676       };
75677     } catch (...) {
75678       {
75679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75680       };
75681     }
75682   }
75683
75684   jresult = result;
75685   return jresult;
75686 }
75687
75688
75689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75690   float jresult ;
75691   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75692   float result;
75693
75694   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75695   {
75696     try {
75697       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75698     } catch (std::out_of_range& e) {
75699       {
75700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (std::exception& e) {
75703       {
75704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75705       };
75706     } catch (Dali::DaliException e) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75709       };
75710     } catch (...) {
75711       {
75712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75713       };
75714     }
75715   }
75716
75717   jresult = result;
75718   return jresult;
75719 }
75720
75721
75722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75723   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75724   Dali::Actor *arg2 = 0 ;
75725   int arg3 ;
75726   Dali::Vector3 *arg4 = 0 ;
75727   Dali::Actor *arg5 = 0 ;
75728
75729   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75730   arg2 = (Dali::Actor *)jarg2;
75731   if (!arg2) {
75732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75733     return ;
75734   }
75735   arg3 = (int)jarg3;
75736   arg4 = (Dali::Vector3 *)jarg4;
75737   if (!arg4) {
75738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75739     return ;
75740   }
75741   arg5 = (Dali::Actor *)jarg5;
75742   if (!arg5) {
75743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75744     return ;
75745   }
75746   {
75747     try {
75748       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75749     } catch (std::out_of_range& e) {
75750       {
75751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75752       };
75753     } catch (std::exception& e) {
75754       {
75755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (Dali::DaliException e) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75760       };
75761     } catch (...) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75764       };
75765     }
75766   }
75767
75768 }
75769
75770
75771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75772   void * jresult ;
75773   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75774   int arg2 ;
75775   float arg3 ;
75776   Dali::Vector3 *arg4 = 0 ;
75777   Dali::Vector3 result;
75778
75779   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75780   arg2 = (int)jarg2;
75781   arg3 = (float)jarg3;
75782   arg4 = (Dali::Vector3 *)jarg4;
75783   if (!arg4) {
75784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75785     return 0;
75786   }
75787   {
75788     try {
75789       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75790     } catch (std::out_of_range& e) {
75791       {
75792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75793       };
75794     } catch (std::exception& e) {
75795       {
75796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75797       };
75798     } catch (Dali::DaliException e) {
75799       {
75800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75801       };
75802     } catch (...) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75805       };
75806     }
75807   }
75808
75809   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75810   return jresult;
75811 }
75812
75813
75814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75815   void * jresult ;
75816   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75817   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75818
75819   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75820   {
75821     try {
75822       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75823     } catch (std::out_of_range& e) {
75824       {
75825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75826       };
75827     } catch (std::exception& e) {
75828       {
75829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75830       };
75831     } catch (Dali::DaliException e) {
75832       {
75833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75834       };
75835     } catch (...) {
75836       {
75837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75838       };
75839     }
75840   }
75841
75842   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75843   return jresult;
75844 }
75845
75846
75847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75848   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75849
75850   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75851   {
75852     try {
75853       delete arg1;
75854     } catch (std::out_of_range& e) {
75855       {
75856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (std::exception& e) {
75859       {
75860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75861       };
75862     } catch (Dali::DaliException e) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75865       };
75866     } catch (...) {
75867       {
75868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75869       };
75870     }
75871   }
75872
75873 }
75874
75875
75876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75877   unsigned int jresult ;
75878   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75879   unsigned int result;
75880
75881   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75882   {
75883     try {
75884       result = (unsigned int)(arg1)->GetNumberOfItems();
75885     } catch (std::out_of_range& e) {
75886       {
75887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (std::exception& e) {
75890       {
75891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75892       };
75893     } catch (Dali::DaliException e) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75900       };
75901     }
75902   }
75903
75904   jresult = result;
75905   return jresult;
75906 }
75907
75908
75909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75910   void * jresult ;
75911   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75912   unsigned int arg2 ;
75913   Dali::Actor result;
75914
75915   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75916   arg2 = (unsigned int)jarg2;
75917   {
75918     try {
75919       result = (arg1)->NewItem(arg2);
75920     } catch (std::out_of_range& e) {
75921       {
75922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75923       };
75924     } catch (std::exception& e) {
75925       {
75926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75927       };
75928     } catch (Dali::DaliException e) {
75929       {
75930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75931       };
75932     } catch (...) {
75933       {
75934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75935       };
75936     }
75937   }
75938
75939   jresult = new Dali::Actor((const Dali::Actor &)result);
75940   return jresult;
75941 }
75942
75943
75944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75945   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75946   unsigned int arg2 ;
75947   Dali::Actor arg3 ;
75948   Dali::Actor *argp3 ;
75949
75950   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75951   arg2 = (unsigned int)jarg2;
75952   argp3 = (Dali::Actor *)jarg3;
75953   if (!argp3) {
75954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75955     return ;
75956   }
75957   arg3 = *argp3;
75958   {
75959     try {
75960       (arg1)->ItemReleased(arg2,arg3);
75961     } catch (std::out_of_range& e) {
75962       {
75963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75964       };
75965     } catch (std::exception& e) {
75966       {
75967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75968       };
75969     } catch (Dali::DaliException e) {
75970       {
75971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75972       };
75973     } catch (...) {
75974       {
75975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75976       };
75977     }
75978   }
75979
75980 }
75981
75982
75983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75984   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75985   unsigned int arg2 ;
75986   Dali::Actor arg3 ;
75987   Dali::Actor *argp3 ;
75988
75989   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75990   arg2 = (unsigned int)jarg2;
75991   argp3 = (Dali::Actor *)jarg3;
75992   if (!argp3) {
75993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75994     return ;
75995   }
75996   arg3 = *argp3;
75997   {
75998     try {
75999       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76000     } catch (std::out_of_range& e) {
76001       {
76002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76003       };
76004     } catch (std::exception& e) {
76005       {
76006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76007       };
76008     } catch (Dali::DaliException e) {
76009       {
76010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76011       };
76012     } catch (...) {
76013       {
76014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76015       };
76016     }
76017   }
76018
76019 }
76020
76021
76022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76023   void * jresult ;
76024   Dali::Toolkit::ItemFactory *result = 0 ;
76025
76026   {
76027     try {
76028       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76029     } catch (std::out_of_range& e) {
76030       {
76031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76032       };
76033     } catch (std::exception& e) {
76034       {
76035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76036       };
76037     } catch (Dali::DaliException e) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76040       };
76041     } catch (...) {
76042       {
76043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76044       };
76045     }
76046   }
76047
76048   jresult = (void *)result;
76049   return jresult;
76050 }
76051
76052
76053 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) {
76054   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76055   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76056   if (director) {
76057     director->swig_connect_director(callback0, callback1, callback2);
76058   }
76059 }
76060
76061
76062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76063   int jresult ;
76064   int result;
76065
76066   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76067   jresult = (int)result;
76068   return jresult;
76069 }
76070
76071
76072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76073   int jresult ;
76074   int result;
76075
76076   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76077   jresult = (int)result;
76078   return jresult;
76079 }
76080
76081
76082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76083   int jresult ;
76084   int result;
76085
76086   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76087   jresult = (int)result;
76088   return jresult;
76089 }
76090
76091
76092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76093   int jresult ;
76094   int result;
76095
76096   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76097   jresult = (int)result;
76098   return jresult;
76099 }
76100
76101
76102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76103   int jresult ;
76104   int result;
76105
76106   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76107   jresult = (int)result;
76108   return jresult;
76109 }
76110
76111
76112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76113   int jresult ;
76114   int result;
76115
76116   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76117   jresult = (int)result;
76118   return jresult;
76119 }
76120
76121
76122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76123   int jresult ;
76124   int result;
76125
76126   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76127   jresult = (int)result;
76128   return jresult;
76129 }
76130
76131
76132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76133   int jresult ;
76134   int result;
76135
76136   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76137   jresult = (int)result;
76138   return jresult;
76139 }
76140
76141
76142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76143   int jresult ;
76144   int result;
76145
76146   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76147   jresult = (int)result;
76148   return jresult;
76149 }
76150
76151
76152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76153   int jresult ;
76154   int result;
76155
76156   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76157   jresult = (int)result;
76158   return jresult;
76159 }
76160
76161
76162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76163   int jresult ;
76164   int result;
76165
76166   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76167   jresult = (int)result;
76168   return jresult;
76169 }
76170
76171
76172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76173   void * jresult ;
76174   Dali::Toolkit::ItemView::Property *result = 0 ;
76175
76176   {
76177     try {
76178       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76179     } catch (std::out_of_range& e) {
76180       {
76181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76182       };
76183     } catch (std::exception& e) {
76184       {
76185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76186       };
76187     } catch (Dali::DaliException e) {
76188       {
76189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76190       };
76191     } catch (...) {
76192       {
76193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76194       };
76195     }
76196   }
76197
76198   jresult = (void *)result;
76199   return jresult;
76200 }
76201
76202
76203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76204   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76205
76206   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76207   {
76208     try {
76209       delete arg1;
76210     } catch (std::out_of_range& e) {
76211       {
76212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76213       };
76214     } catch (std::exception& e) {
76215       {
76216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76217       };
76218     } catch (Dali::DaliException e) {
76219       {
76220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76221       };
76222     } catch (...) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76225       };
76226     }
76227   }
76228
76229 }
76230
76231
76232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76233   void * jresult ;
76234   Dali::Toolkit::ItemView *result = 0 ;
76235
76236   {
76237     try {
76238       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76239     } catch (std::out_of_range& e) {
76240       {
76241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76242       };
76243     } catch (std::exception& e) {
76244       {
76245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76246       };
76247     } catch (Dali::DaliException e) {
76248       {
76249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76250       };
76251     } catch (...) {
76252       {
76253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76254       };
76255     }
76256   }
76257
76258   jresult = (void *)result;
76259   return jresult;
76260 }
76261
76262
76263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76264   void * jresult ;
76265   Dali::Toolkit::ItemView *arg1 = 0 ;
76266   Dali::Toolkit::ItemView *result = 0 ;
76267
76268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76269   if (!arg1) {
76270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76271     return 0;
76272   }
76273   {
76274     try {
76275       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76276     } catch (std::out_of_range& e) {
76277       {
76278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76279       };
76280     } catch (std::exception& e) {
76281       {
76282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76283       };
76284     } catch (Dali::DaliException e) {
76285       {
76286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76287       };
76288     } catch (...) {
76289       {
76290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76291       };
76292     }
76293   }
76294
76295   jresult = (void *)result;
76296   return jresult;
76297 }
76298
76299
76300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76301   void * jresult ;
76302   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76303   Dali::Toolkit::ItemView *arg2 = 0 ;
76304   Dali::Toolkit::ItemView *result = 0 ;
76305
76306   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76307   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76308   if (!arg2) {
76309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76310     return 0;
76311   }
76312   {
76313     try {
76314       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76315     } catch (std::out_of_range& e) {
76316       {
76317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (std::exception& e) {
76320       {
76321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (Dali::DaliException e) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76330       };
76331     }
76332   }
76333
76334   jresult = (void *)result;
76335   return jresult;
76336 }
76337
76338
76339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76340   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76341
76342   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76343   {
76344     try {
76345       delete arg1;
76346     } catch (std::out_of_range& e) {
76347       {
76348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76349       };
76350     } catch (std::exception& e) {
76351       {
76352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76353       };
76354     } catch (Dali::DaliException e) {
76355       {
76356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76357       };
76358     } catch (...) {
76359       {
76360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76361       };
76362     }
76363   }
76364
76365 }
76366
76367
76368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76369   void * jresult ;
76370   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76371   Dali::Toolkit::ItemView result;
76372
76373   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76374   if (!arg1) {
76375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76376     return 0;
76377   }
76378   {
76379     try {
76380       result = Dali::Toolkit::ItemView::New(*arg1);
76381     } catch (std::out_of_range& e) {
76382       {
76383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (std::exception& e) {
76386       {
76387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76388       };
76389     } catch (Dali::DaliException e) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76392       };
76393     } catch (...) {
76394       {
76395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76396       };
76397     }
76398   }
76399
76400   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76401   return jresult;
76402 }
76403
76404
76405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76406   void * jresult ;
76407   Dali::BaseHandle arg1 ;
76408   Dali::BaseHandle *argp1 ;
76409   Dali::Toolkit::ItemView result;
76410
76411   argp1 = (Dali::BaseHandle *)jarg1;
76412   if (!argp1) {
76413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76414     return 0;
76415   }
76416   arg1 = *argp1;
76417   {
76418     try {
76419       result = Dali::Toolkit::ItemView::DownCast(arg1);
76420     } catch (std::out_of_range& e) {
76421       {
76422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76423       };
76424     } catch (std::exception& e) {
76425       {
76426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76427       };
76428     } catch (Dali::DaliException e) {
76429       {
76430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76431       };
76432     } catch (...) {
76433       {
76434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76435       };
76436     }
76437   }
76438
76439   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76440   return jresult;
76441 }
76442
76443
76444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76445   unsigned int jresult ;
76446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76447   unsigned int result;
76448
76449   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76450   {
76451     try {
76452       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76468       };
76469     }
76470   }
76471
76472   jresult = result;
76473   return jresult;
76474 }
76475
76476
76477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76479   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76480
76481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76482   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76483   if (!arg2) {
76484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76485     return ;
76486   }
76487   {
76488     try {
76489       (arg1)->AddLayout(*arg2);
76490     } catch (std::out_of_range& e) {
76491       {
76492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76493       };
76494     } catch (std::exception& e) {
76495       {
76496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76497       };
76498     } catch (Dali::DaliException e) {
76499       {
76500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76501       };
76502     } catch (...) {
76503       {
76504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76505       };
76506     }
76507   }
76508
76509 }
76510
76511
76512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76513   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76514   unsigned int arg2 ;
76515
76516   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76517   arg2 = (unsigned int)jarg2;
76518   {
76519     try {
76520       (arg1)->RemoveLayout(arg2);
76521     } catch (std::out_of_range& e) {
76522       {
76523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76524       };
76525     } catch (std::exception& e) {
76526       {
76527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76528       };
76529     } catch (Dali::DaliException e) {
76530       {
76531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76532       };
76533     } catch (...) {
76534       {
76535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76536       };
76537     }
76538   }
76539
76540 }
76541
76542
76543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76544   void * jresult ;
76545   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76546   unsigned int arg2 ;
76547   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76548
76549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76550   arg2 = (unsigned int)jarg2;
76551   {
76552     try {
76553       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76554     } catch (std::out_of_range& e) {
76555       {
76556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76557       };
76558     } catch (std::exception& e) {
76559       {
76560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76561       };
76562     } catch (Dali::DaliException e) {
76563       {
76564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76565       };
76566     } catch (...) {
76567       {
76568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76569       };
76570     }
76571   }
76572
76573   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76574   return jresult;
76575 }
76576
76577
76578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76579   void * jresult ;
76580   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76581   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76582
76583   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76584   {
76585     try {
76586       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76587     } catch (std::out_of_range& e) {
76588       {
76589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76590       };
76591     } catch (std::exception& e) {
76592       {
76593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76594       };
76595     } catch (Dali::DaliException e) {
76596       {
76597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76598       };
76599     } catch (...) {
76600       {
76601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76602       };
76603     }
76604   }
76605
76606   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76607   return jresult;
76608 }
76609
76610
76611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76612   float jresult ;
76613   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76614   Dali::Toolkit::ItemId arg2 ;
76615   float result;
76616
76617   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76618   arg2 = (Dali::Toolkit::ItemId)jarg2;
76619   {
76620     try {
76621       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76622     } catch (std::out_of_range& e) {
76623       {
76624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76625       };
76626     } catch (std::exception& e) {
76627       {
76628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76629       };
76630     } catch (Dali::DaliException e) {
76631       {
76632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76633       };
76634     } catch (...) {
76635       {
76636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76637       };
76638     }
76639   }
76640
76641   jresult = result;
76642   return jresult;
76643 }
76644
76645
76646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76647   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76648   unsigned int arg2 ;
76649   Dali::Vector3 arg3 ;
76650   float arg4 ;
76651   Dali::Vector3 *argp3 ;
76652
76653   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76654   arg2 = (unsigned int)jarg2;
76655   argp3 = (Dali::Vector3 *)jarg3;
76656   if (!argp3) {
76657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76658     return ;
76659   }
76660   arg3 = *argp3;
76661   arg4 = (float)jarg4;
76662   {
76663     try {
76664       (arg1)->ActivateLayout(arg2,arg3,arg4);
76665     } catch (std::out_of_range& e) {
76666       {
76667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76668       };
76669     } catch (std::exception& e) {
76670       {
76671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76672       };
76673     } catch (Dali::DaliException e) {
76674       {
76675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76676       };
76677     } catch (...) {
76678       {
76679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76680       };
76681     }
76682   }
76683
76684 }
76685
76686
76687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76688   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76689
76690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76691   {
76692     try {
76693       (arg1)->DeactivateCurrentLayout();
76694     } catch (std::out_of_range& e) {
76695       {
76696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76697       };
76698     } catch (std::exception& e) {
76699       {
76700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76701       };
76702     } catch (Dali::DaliException e) {
76703       {
76704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76705       };
76706     } catch (...) {
76707       {
76708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76709       };
76710     }
76711   }
76712
76713 }
76714
76715
76716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76717   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76718   float arg2 ;
76719
76720   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76721   arg2 = (float)jarg2;
76722   {
76723     try {
76724       (arg1)->SetMinimumSwipeSpeed(arg2);
76725     } catch (std::out_of_range& e) {
76726       {
76727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76728       };
76729     } catch (std::exception& e) {
76730       {
76731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76732       };
76733     } catch (Dali::DaliException e) {
76734       {
76735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76736       };
76737     } catch (...) {
76738       {
76739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76740       };
76741     }
76742   }
76743
76744 }
76745
76746
76747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76748   float jresult ;
76749   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76750   float result;
76751
76752   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76753   {
76754     try {
76755       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76756     } catch (std::out_of_range& e) {
76757       {
76758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76759       };
76760     } catch (std::exception& e) {
76761       {
76762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76763       };
76764     } catch (Dali::DaliException e) {
76765       {
76766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76767       };
76768     } catch (...) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76771       };
76772     }
76773   }
76774
76775   jresult = result;
76776   return jresult;
76777 }
76778
76779
76780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76781   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76782   float arg2 ;
76783
76784   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76785   arg2 = (float)jarg2;
76786   {
76787     try {
76788       (arg1)->SetMinimumSwipeDistance(arg2);
76789     } catch (std::out_of_range& e) {
76790       {
76791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76792       };
76793     } catch (std::exception& e) {
76794       {
76795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76796       };
76797     } catch (Dali::DaliException e) {
76798       {
76799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76800       };
76801     } catch (...) {
76802       {
76803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76804       };
76805     }
76806   }
76807
76808 }
76809
76810
76811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76812   float jresult ;
76813   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76814   float result;
76815
76816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76817   {
76818     try {
76819       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76820     } catch (std::out_of_range& e) {
76821       {
76822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76823       };
76824     } catch (std::exception& e) {
76825       {
76826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76827       };
76828     } catch (Dali::DaliException e) {
76829       {
76830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76831       };
76832     } catch (...) {
76833       {
76834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76835       };
76836     }
76837   }
76838
76839   jresult = result;
76840   return jresult;
76841 }
76842
76843
76844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76845   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76846   float arg2 ;
76847
76848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76849   arg2 = (float)jarg2;
76850   {
76851     try {
76852       (arg1)->SetWheelScrollDistanceStep(arg2);
76853     } catch (std::out_of_range& e) {
76854       {
76855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76856       };
76857     } catch (std::exception& e) {
76858       {
76859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76860       };
76861     } catch (Dali::DaliException e) {
76862       {
76863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76864       };
76865     } catch (...) {
76866       {
76867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76868       };
76869     }
76870   }
76871
76872 }
76873
76874
76875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76876   float jresult ;
76877   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76878   float result;
76879
76880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76881   {
76882     try {
76883       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76884     } catch (std::out_of_range& e) {
76885       {
76886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76887       };
76888     } catch (std::exception& e) {
76889       {
76890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76891       };
76892     } catch (Dali::DaliException e) {
76893       {
76894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76895       };
76896     } catch (...) {
76897       {
76898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76899       };
76900     }
76901   }
76902
76903   jresult = result;
76904   return jresult;
76905 }
76906
76907
76908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76910   bool arg2 ;
76911
76912   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76913   arg2 = jarg2 ? true : false;
76914   {
76915     try {
76916       (arg1)->SetAnchoring(arg2);
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76924       };
76925     } catch (Dali::DaliException e) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76928       };
76929     } catch (...) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76932       };
76933     }
76934   }
76935
76936 }
76937
76938 //// ========================= end of part 3 =============================
76939
76940 //// ========================== start part 4 ===============================
76941
76942
76943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76944   unsigned int jresult ;
76945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76946   bool result;
76947
76948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76949   {
76950     try {
76951       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76952     } catch (std::out_of_range& e) {
76953       {
76954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (std::exception& e) {
76957       {
76958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76959       };
76960     } catch (Dali::DaliException e) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76963       };
76964     } catch (...) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76967       };
76968     }
76969   }
76970
76971   jresult = result;
76972   return jresult;
76973 }
76974
76975
76976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76978   float arg2 ;
76979
76980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76981   arg2 = (float)jarg2;
76982   {
76983     try {
76984       (arg1)->SetAnchoringDuration(arg2);
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77000       };
77001     }
77002   }
77003
77004 }
77005
77006
77007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77008   float jresult ;
77009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77010   float result;
77011
77012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77013   {
77014     try {
77015       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77016     } catch (std::out_of_range& e) {
77017       {
77018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77019       };
77020     } catch (std::exception& e) {
77021       {
77022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (Dali::DaliException e) {
77025       {
77026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77027       };
77028     } catch (...) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77031       };
77032     }
77033   }
77034
77035   jresult = result;
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77042   Dali::Toolkit::ItemId arg2 ;
77043   float arg3 ;
77044
77045   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77046   arg2 = (Dali::Toolkit::ItemId)jarg2;
77047   arg3 = (float)jarg3;
77048   {
77049     try {
77050       (arg1)->ScrollToItem(arg2,arg3);
77051     } catch (std::out_of_range& e) {
77052       {
77053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77054       };
77055     } catch (std::exception& e) {
77056       {
77057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77058       };
77059     } catch (Dali::DaliException e) {
77060       {
77061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77062       };
77063     } catch (...) {
77064       {
77065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77066       };
77067     }
77068   }
77069
77070 }
77071
77072
77073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77074   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77075   float arg2 ;
77076
77077   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77078   arg2 = (float)jarg2;
77079   {
77080     try {
77081       (arg1)->SetRefreshInterval(arg2);
77082     } catch (std::out_of_range& e) {
77083       {
77084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77085       };
77086     } catch (std::exception& e) {
77087       {
77088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77089       };
77090     } catch (Dali::DaliException e) {
77091       {
77092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77093       };
77094     } catch (...) {
77095       {
77096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77097       };
77098     }
77099   }
77100
77101 }
77102
77103
77104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77105   float jresult ;
77106   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77107   float result;
77108
77109   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77110   {
77111     try {
77112       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77113     } catch (std::out_of_range& e) {
77114       {
77115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77116       };
77117     } catch (std::exception& e) {
77118       {
77119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77120       };
77121     } catch (Dali::DaliException e) {
77122       {
77123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77124       };
77125     } catch (...) {
77126       {
77127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77128       };
77129     }
77130   }
77131
77132   jresult = result;
77133   return jresult;
77134 }
77135
77136
77137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77138   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77139
77140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77141   {
77142     try {
77143       (arg1)->Refresh();
77144     } catch (std::out_of_range& e) {
77145       {
77146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77147       };
77148     } catch (std::exception& e) {
77149       {
77150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77151       };
77152     } catch (Dali::DaliException e) {
77153       {
77154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77155       };
77156     } catch (...) {
77157       {
77158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77159       };
77160     }
77161   }
77162
77163 }
77164
77165
77166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77167   void * jresult ;
77168   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77169   Dali::Toolkit::ItemId arg2 ;
77170   Dali::Actor result;
77171
77172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77173   arg2 = (Dali::Toolkit::ItemId)jarg2;
77174   {
77175     try {
77176       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77177     } catch (std::out_of_range& e) {
77178       {
77179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77180       };
77181     } catch (std::exception& e) {
77182       {
77183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77184       };
77185     } catch (Dali::DaliException e) {
77186       {
77187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77188       };
77189     } catch (...) {
77190       {
77191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77192       };
77193     }
77194   }
77195
77196   jresult = new Dali::Actor((const Dali::Actor &)result);
77197   return jresult;
77198 }
77199
77200
77201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77202   unsigned int jresult ;
77203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77204   Dali::Actor arg2 ;
77205   Dali::Actor *argp2 ;
77206   Dali::Toolkit::ItemId result;
77207
77208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77209   argp2 = (Dali::Actor *)jarg2;
77210   if (!argp2) {
77211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77212     return 0;
77213   }
77214   arg2 = *argp2;
77215   {
77216     try {
77217       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77225       };
77226     } catch (Dali::DaliException e) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77229       };
77230     } catch (...) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77233       };
77234     }
77235   }
77236
77237   jresult = result;
77238   return jresult;
77239 }
77240
77241
77242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77243   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77244   Dali::Toolkit::Item arg2 ;
77245   float arg3 ;
77246   Dali::Toolkit::Item *argp2 ;
77247
77248   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77249   argp2 = (Dali::Toolkit::Item *)jarg2;
77250   if (!argp2) {
77251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77252     return ;
77253   }
77254   arg2 = *argp2;
77255   arg3 = (float)jarg3;
77256   {
77257     try {
77258       (arg1)->InsertItem(arg2,arg3);
77259     } catch (std::out_of_range& e) {
77260       {
77261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77262       };
77263     } catch (std::exception& e) {
77264       {
77265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77266       };
77267     } catch (Dali::DaliException e) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77270       };
77271     } catch (...) {
77272       {
77273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77274       };
77275     }
77276   }
77277
77278 }
77279
77280
77281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77282   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77283   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77284   float arg3 ;
77285
77286   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77287   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77288   if (!arg2) {
77289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77290     return ;
77291   }
77292   arg3 = (float)jarg3;
77293   {
77294     try {
77295       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77296     } catch (std::out_of_range& e) {
77297       {
77298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77299       };
77300     } catch (std::exception& e) {
77301       {
77302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77303       };
77304     } catch (Dali::DaliException e) {
77305       {
77306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77307       };
77308     } catch (...) {
77309       {
77310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77311       };
77312     }
77313   }
77314
77315 }
77316
77317
77318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77319   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77320   Dali::Toolkit::ItemId arg2 ;
77321   float arg3 ;
77322
77323   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77324   arg2 = (Dali::Toolkit::ItemId)jarg2;
77325   arg3 = (float)jarg3;
77326   {
77327     try {
77328       (arg1)->RemoveItem(arg2,arg3);
77329     } catch (std::out_of_range& e) {
77330       {
77331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77332       };
77333     } catch (std::exception& e) {
77334       {
77335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77336       };
77337     } catch (Dali::DaliException e) {
77338       {
77339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77340       };
77341     } catch (...) {
77342       {
77343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77344       };
77345     }
77346   }
77347
77348 }
77349
77350
77351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77352   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77353   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77354   float arg3 ;
77355
77356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77357   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77358   if (!arg2) {
77359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77360     return ;
77361   }
77362   arg3 = (float)jarg3;
77363   {
77364     try {
77365       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77373       };
77374     } catch (Dali::DaliException e) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77377       };
77378     } catch (...) {
77379       {
77380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77381       };
77382     }
77383   }
77384
77385 }
77386
77387
77388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77389   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77390   Dali::Toolkit::Item arg2 ;
77391   float arg3 ;
77392   Dali::Toolkit::Item *argp2 ;
77393
77394   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77395   argp2 = (Dali::Toolkit::Item *)jarg2;
77396   if (!argp2) {
77397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77398     return ;
77399   }
77400   arg2 = *argp2;
77401   arg3 = (float)jarg3;
77402   {
77403     try {
77404       (arg1)->ReplaceItem(arg2,arg3);
77405     } catch (std::out_of_range& e) {
77406       {
77407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77408       };
77409     } catch (std::exception& e) {
77410       {
77411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77412       };
77413     } catch (Dali::DaliException e) {
77414       {
77415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77416       };
77417     } catch (...) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77420       };
77421     }
77422   }
77423
77424 }
77425
77426
77427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77428   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77429   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77430   float arg3 ;
77431
77432   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77433   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77434   if (!arg2) {
77435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77436     return ;
77437   }
77438   arg3 = (float)jarg3;
77439   {
77440     try {
77441       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77442     } catch (std::out_of_range& e) {
77443       {
77444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77445       };
77446     } catch (std::exception& e) {
77447       {
77448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77449       };
77450     } catch (Dali::DaliException e) {
77451       {
77452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77453       };
77454     } catch (...) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77457       };
77458     }
77459   }
77460
77461 }
77462
77463
77464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77465   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77466   Dali::Vector3 *arg2 = 0 ;
77467
77468   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77469   arg2 = (Dali::Vector3 *)jarg2;
77470   if (!arg2) {
77471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77472     return ;
77473   }
77474   {
77475     try {
77476       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77477     } catch (std::out_of_range& e) {
77478       {
77479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77480       };
77481     } catch (std::exception& e) {
77482       {
77483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77484       };
77485     } catch (Dali::DaliException e) {
77486       {
77487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77488       };
77489     } catch (...) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77492       };
77493     }
77494   }
77495
77496 }
77497
77498
77499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77500   void * jresult ;
77501   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77502   Dali::Vector3 result;
77503
77504   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77505   {
77506     try {
77507       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77508     } catch (std::out_of_range& e) {
77509       {
77510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77511       };
77512     } catch (std::exception& e) {
77513       {
77514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77515       };
77516     } catch (Dali::DaliException e) {
77517       {
77518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77519       };
77520     } catch (...) {
77521       {
77522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77523       };
77524     }
77525   }
77526
77527   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77528   return jresult;
77529 }
77530
77531
77532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77533   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77534   Dali::Vector3 *arg2 = 0 ;
77535
77536   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77537   arg2 = (Dali::Vector3 *)jarg2;
77538   if (!arg2) {
77539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77540     return ;
77541   }
77542   {
77543     try {
77544       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77545     } catch (std::out_of_range& e) {
77546       {
77547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77548       };
77549     } catch (std::exception& e) {
77550       {
77551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77552       };
77553     } catch (Dali::DaliException e) {
77554       {
77555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77556       };
77557     } catch (...) {
77558       {
77559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77560       };
77561     }
77562   }
77563
77564 }
77565
77566
77567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77568   void * jresult ;
77569   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77570   Dali::Vector3 result;
77571
77572   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77573   {
77574     try {
77575       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77576     } catch (std::out_of_range& e) {
77577       {
77578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77579       };
77580     } catch (std::exception& e) {
77581       {
77582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77583       };
77584     } catch (Dali::DaliException e) {
77585       {
77586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77587       };
77588     } catch (...) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77591       };
77592     }
77593   }
77594
77595   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77596   return jresult;
77597 }
77598
77599
77600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77601   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77602   Dali::Toolkit::ItemRange *arg2 = 0 ;
77603
77604   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77605   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77606   if (!arg2) {
77607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77608     return ;
77609   }
77610   {
77611     try {
77612       (arg1)->GetItemsRange(*arg2);
77613     } catch (std::out_of_range& e) {
77614       {
77615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77616       };
77617     } catch (std::exception& e) {
77618       {
77619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77620       };
77621     } catch (Dali::DaliException e) {
77622       {
77623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77624       };
77625     } catch (...) {
77626       {
77627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77628       };
77629     }
77630   }
77631
77632 }
77633
77634
77635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77636   void * jresult ;
77637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77638   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77639
77640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77641   {
77642     try {
77643       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77651       };
77652     } catch (Dali::DaliException e) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77655       };
77656     } catch (...) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77659       };
77660     }
77661   }
77662
77663   jresult = (void *)result;
77664   return jresult;
77665 }
77666
77667
77668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77669   Dali::Vector3 *arg1 = 0 ;
77670   PropertyInputContainer *arg2 = 0 ;
77671
77672   arg1 = (Dali::Vector3 *)jarg1;
77673   if (!arg1) {
77674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77675     return ;
77676   }
77677   arg2 = (PropertyInputContainer *)jarg2;
77678   if (!arg2) {
77679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77680     return ;
77681   }
77682   {
77683     try {
77684       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77685     } catch (std::out_of_range& e) {
77686       {
77687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77688       };
77689     } catch (std::exception& e) {
77690       {
77691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77692       };
77693     } catch (Dali::DaliException e) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77696       };
77697     } catch (...) {
77698       {
77699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77700       };
77701     }
77702   }
77703
77704 }
77705
77706
77707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77708   Dali::Vector3 *arg1 = 0 ;
77709   PropertyInputContainer *arg2 = 0 ;
77710
77711   arg1 = (Dali::Vector3 *)jarg1;
77712   if (!arg1) {
77713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77714     return ;
77715   }
77716   arg2 = (PropertyInputContainer *)jarg2;
77717   if (!arg2) {
77718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77719     return ;
77720   }
77721   {
77722     try {
77723       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77724     } catch (std::out_of_range& e) {
77725       {
77726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77727       };
77728     } catch (std::exception& e) {
77729       {
77730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77731       };
77732     } catch (Dali::DaliException e) {
77733       {
77734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77735       };
77736     } catch (...) {
77737       {
77738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77739       };
77740     }
77741   }
77742
77743 }
77744
77745
77746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77747   void * jresult ;
77748   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77749
77750   {
77751     try {
77752       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77753     } catch (std::out_of_range& e) {
77754       {
77755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77756       };
77757     } catch (std::exception& e) {
77758       {
77759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77760       };
77761     } catch (Dali::DaliException e) {
77762       {
77763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77764       };
77765     } catch (...) {
77766       {
77767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77768       };
77769     }
77770   }
77771
77772   jresult = (void *)result;
77773   return jresult;
77774 }
77775
77776
77777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77778   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77779
77780   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77781   {
77782     try {
77783       delete arg1;
77784     } catch (std::out_of_range& e) {
77785       {
77786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77787       };
77788     } catch (std::exception& e) {
77789       {
77790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77791       };
77792     } catch (Dali::DaliException e) {
77793       {
77794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77795       };
77796     } catch (...) {
77797       {
77798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77799       };
77800     }
77801   }
77802
77803 }
77804
77805
77806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77807   void * jresult ;
77808   Dali::Path arg1 ;
77809   Dali::Vector3 *arg2 = 0 ;
77810   Dali::Property::Index arg3 ;
77811   Dali::Vector3 *arg4 = 0 ;
77812   unsigned int arg5 ;
77813   Dali::Path *argp1 ;
77814   Dali::Toolkit::ScrollViewPagePathEffect result;
77815
77816   argp1 = (Dali::Path *)jarg1;
77817   if (!argp1) {
77818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77819     return 0;
77820   }
77821   arg1 = *argp1;
77822   arg2 = (Dali::Vector3 *)jarg2;
77823   if (!arg2) {
77824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77825     return 0;
77826   }
77827   arg3 = (Dali::Property::Index)jarg3;
77828   arg4 = (Dali::Vector3 *)jarg4;
77829   if (!arg4) {
77830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77831     return 0;
77832   }
77833   arg5 = (unsigned int)jarg5;
77834   {
77835     try {
77836       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77837     } catch (std::out_of_range& e) {
77838       {
77839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77840       };
77841     } catch (std::exception& e) {
77842       {
77843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77844       };
77845     } catch (Dali::DaliException e) {
77846       {
77847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77848       };
77849     } catch (...) {
77850       {
77851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77852       };
77853     }
77854   }
77855
77856   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77857   return jresult;
77858 }
77859
77860
77861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77862   void * jresult ;
77863   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77864
77865   {
77866     try {
77867       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77868     } catch (std::out_of_range& e) {
77869       {
77870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77871       };
77872     } catch (std::exception& e) {
77873       {
77874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77875       };
77876     } catch (Dali::DaliException e) {
77877       {
77878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77879       };
77880     } catch (...) {
77881       {
77882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77883       };
77884     }
77885   }
77886
77887   jresult = (void *)result;
77888   return jresult;
77889 }
77890
77891
77892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77893   void * jresult ;
77894   Dali::BaseHandle arg1 ;
77895   Dali::BaseHandle *argp1 ;
77896   Dali::Toolkit::ScrollViewPagePathEffect result;
77897
77898   argp1 = (Dali::BaseHandle *)jarg1;
77899   if (!argp1) {
77900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77901     return 0;
77902   }
77903   arg1 = *argp1;
77904   {
77905     try {
77906       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77907     } catch (std::out_of_range& e) {
77908       {
77909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77910       };
77911     } catch (std::exception& e) {
77912       {
77913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77914       };
77915     } catch (Dali::DaliException e) {
77916       {
77917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77918       };
77919     } catch (...) {
77920       {
77921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77922       };
77923     }
77924   }
77925
77926   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77927   return jresult;
77928 }
77929
77930
77931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77932   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77933   Dali::Actor arg2 ;
77934   unsigned int arg3 ;
77935   Dali::Actor *argp2 ;
77936
77937   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77938   argp2 = (Dali::Actor *)jarg2;
77939   if (!argp2) {
77940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77941     return ;
77942   }
77943   arg2 = *argp2;
77944   arg3 = (unsigned int)jarg3;
77945   {
77946     try {
77947       (arg1)->ApplyToPage(arg2,arg3);
77948     } catch (std::out_of_range& e) {
77949       {
77950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77951       };
77952     } catch (std::exception& e) {
77953       {
77954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77955       };
77956     } catch (Dali::DaliException e) {
77957       {
77958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77959       };
77960     } catch (...) {
77961       {
77962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77963       };
77964     }
77965   }
77966
77967 }
77968
77969
77970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77971   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77972
77973   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77974   {
77975     try {
77976       delete arg1;
77977     } catch (std::out_of_range& e) {
77978       {
77979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77980       };
77981     } catch (std::exception& e) {
77982       {
77983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77984       };
77985     } catch (Dali::DaliException e) {
77986       {
77987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77988       };
77989     } catch (...) {
77990       {
77991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77992       };
77993     }
77994   }
77995
77996 }
77997
77998
77999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78000   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78001   Dali::Toolkit::ClampState arg2 ;
78002
78003   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78004   arg2 = (Dali::Toolkit::ClampState)jarg2;
78005   if (arg1) (arg1)->x = arg2;
78006 }
78007
78008
78009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78010   int jresult ;
78011   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78012   Dali::Toolkit::ClampState result;
78013
78014   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78015   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78016   jresult = (int)result;
78017   return jresult;
78018 }
78019
78020
78021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78022   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78023   Dali::Toolkit::ClampState arg2 ;
78024
78025   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78026   arg2 = (Dali::Toolkit::ClampState)jarg2;
78027   if (arg1) (arg1)->y = arg2;
78028 }
78029
78030
78031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78032   int jresult ;
78033   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78034   Dali::Toolkit::ClampState result;
78035
78036   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78037   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78038   jresult = (int)result;
78039   return jresult;
78040 }
78041
78042
78043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78044   void * jresult ;
78045   Dali::Toolkit::ClampState2D *result = 0 ;
78046
78047   {
78048     try {
78049       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78050     } catch (std::out_of_range& e) {
78051       {
78052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78053       };
78054     } catch (std::exception& e) {
78055       {
78056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78057       };
78058     } catch (Dali::DaliException e) {
78059       {
78060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78061       };
78062     } catch (...) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78065       };
78066     }
78067   }
78068
78069   jresult = (void *)result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78075   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78076
78077   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78078   {
78079     try {
78080       delete arg1;
78081     } catch (std::out_of_range& e) {
78082       {
78083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78084       };
78085     } catch (std::exception& e) {
78086       {
78087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78088       };
78089     } catch (Dali::DaliException e) {
78090       {
78091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78092       };
78093     } catch (...) {
78094       {
78095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78096       };
78097     }
78098   }
78099
78100 }
78101
78102
78103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78104   void * jresult ;
78105   float arg1 ;
78106   float arg2 ;
78107   bool arg3 ;
78108   Dali::Toolkit::RulerDomain *result = 0 ;
78109
78110   arg1 = (float)jarg1;
78111   arg2 = (float)jarg2;
78112   arg3 = jarg3 ? true : false;
78113   {
78114     try {
78115       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78116     } catch (std::out_of_range& e) {
78117       {
78118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78119       };
78120     } catch (std::exception& e) {
78121       {
78122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78123       };
78124     } catch (Dali::DaliException e) {
78125       {
78126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78127       };
78128     } catch (...) {
78129       {
78130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78131       };
78132     }
78133   }
78134
78135   jresult = (void *)result;
78136   return jresult;
78137 }
78138
78139
78140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78141   void * jresult ;
78142   float arg1 ;
78143   float arg2 ;
78144   Dali::Toolkit::RulerDomain *result = 0 ;
78145
78146   arg1 = (float)jarg1;
78147   arg2 = (float)jarg2;
78148   {
78149     try {
78150       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78158       };
78159     } catch (Dali::DaliException e) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78162       };
78163     } catch (...) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78166       };
78167     }
78168   }
78169
78170   jresult = (void *)result;
78171   return jresult;
78172 }
78173
78174
78175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78176   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78177   float arg2 ;
78178
78179   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78180   arg2 = (float)jarg2;
78181   if (arg1) (arg1)->min = arg2;
78182 }
78183
78184
78185 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78186   float jresult ;
78187   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78188   float result;
78189
78190   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78191   result = (float) ((arg1)->min);
78192   jresult = result;
78193   return jresult;
78194 }
78195
78196
78197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78198   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78199   float arg2 ;
78200
78201   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78202   arg2 = (float)jarg2;
78203   if (arg1) (arg1)->max = arg2;
78204 }
78205
78206
78207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78208   float jresult ;
78209   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78210   float result;
78211
78212   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78213   result = (float) ((arg1)->max);
78214   jresult = result;
78215   return jresult;
78216 }
78217
78218
78219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78220   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78221   bool arg2 ;
78222
78223   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78224   arg2 = jarg2 ? true : false;
78225   if (arg1) (arg1)->enabled = arg2;
78226 }
78227
78228
78229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78230   unsigned int jresult ;
78231   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78232   bool result;
78233
78234   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78235   result = (bool) ((arg1)->enabled);
78236   jresult = result;
78237   return jresult;
78238 }
78239
78240
78241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78242   float jresult ;
78243   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78244   float arg2 ;
78245   float arg3 ;
78246   float arg4 ;
78247   float result;
78248
78249   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78250   arg2 = (float)jarg2;
78251   arg3 = (float)jarg3;
78252   arg4 = (float)jarg4;
78253   {
78254     try {
78255       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78256     } catch (std::out_of_range& e) {
78257       {
78258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (std::exception& e) {
78261       {
78262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78263       };
78264     } catch (Dali::DaliException e) {
78265       {
78266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78267       };
78268     } catch (...) {
78269       {
78270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78271       };
78272     }
78273   }
78274
78275   jresult = result;
78276   return jresult;
78277 }
78278
78279
78280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78281   float jresult ;
78282   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78283   float arg2 ;
78284   float arg3 ;
78285   float result;
78286
78287   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78288   arg2 = (float)jarg2;
78289   arg3 = (float)jarg3;
78290   {
78291     try {
78292       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78293     } catch (std::out_of_range& e) {
78294       {
78295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78296       };
78297     } catch (std::exception& e) {
78298       {
78299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78300       };
78301     } catch (Dali::DaliException e) {
78302       {
78303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78304       };
78305     } catch (...) {
78306       {
78307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78308       };
78309     }
78310   }
78311
78312   jresult = result;
78313   return jresult;
78314 }
78315
78316
78317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78318   float jresult ;
78319   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78320   float arg2 ;
78321   float result;
78322
78323   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78324   arg2 = (float)jarg2;
78325   {
78326     try {
78327       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78328     } catch (std::out_of_range& e) {
78329       {
78330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78331       };
78332     } catch (std::exception& e) {
78333       {
78334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78335       };
78336     } catch (Dali::DaliException e) {
78337       {
78338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78339       };
78340     } catch (...) {
78341       {
78342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78343       };
78344     }
78345   }
78346
78347   jresult = result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78353   float jresult ;
78354   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78355   float arg2 ;
78356   float arg3 ;
78357   float arg4 ;
78358   Dali::Toolkit::ClampState *arg5 = 0 ;
78359   float result;
78360
78361   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78362   arg2 = (float)jarg2;
78363   arg3 = (float)jarg3;
78364   arg4 = (float)jarg4;
78365   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78366   if (!arg5) {
78367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78368     return 0;
78369   }
78370   {
78371     try {
78372       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78373     } catch (std::out_of_range& e) {
78374       {
78375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78376       };
78377     } catch (std::exception& e) {
78378       {
78379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78380       };
78381     } catch (Dali::DaliException e) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78384       };
78385     } catch (...) {
78386       {
78387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78388       };
78389     }
78390   }
78391
78392   jresult = result;
78393   return jresult;
78394 }
78395
78396
78397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78398   float jresult ;
78399   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78400   float result;
78401
78402   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78403   {
78404     try {
78405       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78406     } catch (std::out_of_range& e) {
78407       {
78408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78409       };
78410     } catch (std::exception& e) {
78411       {
78412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78413       };
78414     } catch (Dali::DaliException e) {
78415       {
78416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78417       };
78418     } catch (...) {
78419       {
78420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78421       };
78422     }
78423   }
78424
78425   jresult = result;
78426   return jresult;
78427 }
78428
78429
78430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78431   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78432
78433   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78434   {
78435     try {
78436       delete arg1;
78437     } catch (std::out_of_range& e) {
78438       {
78439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78440       };
78441     } catch (std::exception& e) {
78442       {
78443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78444       };
78445     } catch (Dali::DaliException e) {
78446       {
78447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78452       };
78453     }
78454   }
78455
78456 }
78457
78458
78459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78460   float jresult ;
78461   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78462   float arg2 ;
78463   float arg3 ;
78464   float result;
78465
78466   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78467   arg2 = (float)jarg2;
78468   arg3 = (float)jarg3;
78469   {
78470     try {
78471       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78472     } catch (std::out_of_range& e) {
78473       {
78474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78475       };
78476     } catch (std::exception& e) {
78477       {
78478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78479       };
78480     } catch (Dali::DaliException e) {
78481       {
78482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78483       };
78484     } catch (...) {
78485       {
78486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78487       };
78488     }
78489   }
78490
78491   jresult = result;
78492   return jresult;
78493 }
78494
78495
78496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78497   float jresult ;
78498   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78499   float arg2 ;
78500   float result;
78501
78502   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78503   arg2 = (float)jarg2;
78504   {
78505     try {
78506       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78507     } catch (std::out_of_range& e) {
78508       {
78509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78510       };
78511     } catch (std::exception& e) {
78512       {
78513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78514       };
78515     } catch (Dali::DaliException e) {
78516       {
78517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78518       };
78519     } catch (...) {
78520       {
78521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78522       };
78523     }
78524   }
78525
78526   jresult = result;
78527   return jresult;
78528 }
78529
78530
78531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78532   float jresult ;
78533   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78534   unsigned int arg2 ;
78535   unsigned int *arg3 = 0 ;
78536   bool arg4 ;
78537   float result;
78538
78539   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78540   arg2 = (unsigned int)jarg2;
78541   arg3 = (unsigned int *)jarg3;
78542   arg4 = jarg4 ? true : false;
78543   {
78544     try {
78545       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78546     } catch (std::out_of_range& e) {
78547       {
78548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78549       };
78550     } catch (std::exception& e) {
78551       {
78552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78553       };
78554     } catch (Dali::DaliException e) {
78555       {
78556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78557       };
78558     } catch (...) {
78559       {
78560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78561       };
78562     }
78563   }
78564
78565   jresult = result;
78566   return jresult;
78567 }
78568
78569
78570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78571   unsigned int jresult ;
78572   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78573   float arg2 ;
78574   bool arg3 ;
78575   unsigned int result;
78576
78577   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78578   arg2 = (float)jarg2;
78579   arg3 = jarg3 ? true : false;
78580   {
78581     try {
78582       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78583     } catch (std::out_of_range& e) {
78584       {
78585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78586       };
78587     } catch (std::exception& e) {
78588       {
78589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78590       };
78591     } catch (Dali::DaliException e) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78594       };
78595     } catch (...) {
78596       {
78597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78598       };
78599     }
78600   }
78601
78602   jresult = result;
78603   return jresult;
78604 }
78605
78606
78607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78608   unsigned int jresult ;
78609   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78610   unsigned int result;
78611
78612   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78613   {
78614     try {
78615       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78616     } catch (std::out_of_range& e) {
78617       {
78618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78619       };
78620     } catch (std::exception& e) {
78621       {
78622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78623       };
78624     } catch (Dali::DaliException e) {
78625       {
78626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78627       };
78628     } catch (...) {
78629       {
78630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78631       };
78632     }
78633   }
78634
78635   jresult = result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78641   int jresult ;
78642   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78643   Dali::Toolkit::Ruler::RulerType result;
78644
78645   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78646   {
78647     try {
78648       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78649     } catch (std::out_of_range& e) {
78650       {
78651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78652       };
78653     } catch (std::exception& e) {
78654       {
78655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78656       };
78657     } catch (Dali::DaliException e) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78660       };
78661     } catch (...) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78664       };
78665     }
78666   }
78667
78668   jresult = (int)result;
78669   return jresult;
78670 }
78671
78672
78673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78674   unsigned int jresult ;
78675   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78676   bool result;
78677
78678   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78679   {
78680     try {
78681       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78682     } catch (std::out_of_range& e) {
78683       {
78684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78685       };
78686     } catch (std::exception& e) {
78687       {
78688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (Dali::DaliException e) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78693       };
78694     } catch (...) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78697       };
78698     }
78699   }
78700
78701   jresult = result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78707   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78708
78709   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78710   {
78711     try {
78712       (arg1)->Enable();
78713     } catch (std::out_of_range& e) {
78714       {
78715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78716       };
78717     } catch (std::exception& e) {
78718       {
78719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78720       };
78721     } catch (Dali::DaliException e) {
78722       {
78723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78724       };
78725     } catch (...) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78728       };
78729     }
78730   }
78731
78732 }
78733
78734
78735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78736   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78737
78738   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78739   {
78740     try {
78741       (arg1)->Disable();
78742     } catch (std::out_of_range& e) {
78743       {
78744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78745       };
78746     } catch (std::exception& e) {
78747       {
78748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78749       };
78750     } catch (Dali::DaliException e) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78753       };
78754     } catch (...) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78757       };
78758     }
78759   }
78760
78761 }
78762
78763
78764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78765   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78766   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78767   Dali::Toolkit::RulerDomain *argp2 ;
78768
78769   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78770   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78771   if (!argp2) {
78772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78773     return ;
78774   }
78775   arg2 = *argp2;
78776   {
78777     try {
78778       (arg1)->SetDomain(arg2);
78779     } catch (std::out_of_range& e) {
78780       {
78781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78782       };
78783     } catch (std::exception& e) {
78784       {
78785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78786       };
78787     } catch (Dali::DaliException e) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78790       };
78791     } catch (...) {
78792       {
78793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78794       };
78795     }
78796   }
78797
78798 }
78799
78800
78801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78802   void * jresult ;
78803   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78804   Dali::Toolkit::RulerDomain *result = 0 ;
78805
78806   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78807   {
78808     try {
78809       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78810     } catch (std::out_of_range& e) {
78811       {
78812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (std::exception& e) {
78815       {
78816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78817       };
78818     } catch (Dali::DaliException e) {
78819       {
78820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78821       };
78822     } catch (...) {
78823       {
78824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78825       };
78826     }
78827   }
78828
78829   jresult = (void *)result;
78830   return jresult;
78831 }
78832
78833
78834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78835   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78836
78837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78838   {
78839     try {
78840       (arg1)->DisableDomain();
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78848       };
78849     } catch (Dali::DaliException e) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78852       };
78853     } catch (...) {
78854       {
78855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78856       };
78857     }
78858   }
78859
78860 }
78861
78862
78863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78864   float jresult ;
78865   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78866   float arg2 ;
78867   float arg3 ;
78868   float arg4 ;
78869   float result;
78870
78871   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78872   arg2 = (float)jarg2;
78873   arg3 = (float)jarg3;
78874   arg4 = (float)jarg4;
78875   {
78876     try {
78877       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78878     } catch (std::out_of_range& e) {
78879       {
78880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78881       };
78882     } catch (std::exception& e) {
78883       {
78884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (Dali::DaliException e) {
78887       {
78888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78889       };
78890     } catch (...) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78893       };
78894     }
78895   }
78896
78897   jresult = result;
78898   return jresult;
78899 }
78900
78901
78902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78903   float jresult ;
78904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78905   float arg2 ;
78906   float arg3 ;
78907   float result;
78908
78909   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78910   arg2 = (float)jarg2;
78911   arg3 = (float)jarg3;
78912   {
78913     try {
78914       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78915     } catch (std::out_of_range& e) {
78916       {
78917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78918       };
78919     } catch (std::exception& e) {
78920       {
78921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78922       };
78923     } catch (Dali::DaliException e) {
78924       {
78925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78926       };
78927     } catch (...) {
78928       {
78929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78930       };
78931     }
78932   }
78933
78934   jresult = result;
78935   return jresult;
78936 }
78937
78938
78939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78940   float jresult ;
78941   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78942   float arg2 ;
78943   float result;
78944
78945   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78946   arg2 = (float)jarg2;
78947   {
78948     try {
78949       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78950     } catch (std::out_of_range& e) {
78951       {
78952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (std::exception& e) {
78955       {
78956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78957       };
78958     } catch (Dali::DaliException e) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78961       };
78962     } catch (...) {
78963       {
78964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78965       };
78966     }
78967   }
78968
78969   jresult = result;
78970   return jresult;
78971 }
78972
78973
78974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78975   float jresult ;
78976   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78977   float arg2 ;
78978   float arg3 ;
78979   float arg4 ;
78980   Dali::Toolkit::ClampState *arg5 = 0 ;
78981   float result;
78982
78983   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78984   arg2 = (float)jarg2;
78985   arg3 = (float)jarg3;
78986   arg4 = (float)jarg4;
78987   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78988   if (!arg5) {
78989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78990     return 0;
78991   }
78992   {
78993     try {
78994       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (Dali::DaliException e) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79006       };
79007     } catch (...) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79010       };
79011     }
79012   }
79013
79014   jresult = result;
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79020   float jresult ;
79021   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79022   float arg2 ;
79023   float arg3 ;
79024   float arg4 ;
79025   float arg5 ;
79026   float result;
79027
79028   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79029   arg2 = (float)jarg2;
79030   arg3 = (float)jarg3;
79031   arg4 = (float)jarg4;
79032   arg5 = (float)jarg5;
79033   {
79034     try {
79035       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79036     } catch (std::out_of_range& e) {
79037       {
79038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79039       };
79040     } catch (std::exception& e) {
79041       {
79042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79043       };
79044     } catch (Dali::DaliException e) {
79045       {
79046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79047       };
79048     } catch (...) {
79049       {
79050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79051       };
79052     }
79053   }
79054
79055   jresult = result;
79056   return jresult;
79057 }
79058
79059
79060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79061   float jresult ;
79062   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79063   float arg2 ;
79064   float arg3 ;
79065   float arg4 ;
79066   float result;
79067
79068   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79069   arg2 = (float)jarg2;
79070   arg3 = (float)jarg3;
79071   arg4 = (float)jarg4;
79072   {
79073     try {
79074       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79075     } catch (std::out_of_range& e) {
79076       {
79077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (std::exception& e) {
79080       {
79081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (Dali::DaliException e) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79090       };
79091     }
79092   }
79093
79094   jresult = result;
79095   return jresult;
79096 }
79097
79098
79099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79100   float jresult ;
79101   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79102   float arg2 ;
79103   float arg3 ;
79104   float result;
79105
79106   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79107   arg2 = (float)jarg2;
79108   arg3 = (float)jarg3;
79109   {
79110     try {
79111       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79112     } catch (std::out_of_range& e) {
79113       {
79114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79115       };
79116     } catch (std::exception& e) {
79117       {
79118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79119       };
79120     } catch (Dali::DaliException e) {
79121       {
79122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79123       };
79124     } catch (...) {
79125       {
79126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79127       };
79128     }
79129   }
79130
79131   jresult = result;
79132   return jresult;
79133 }
79134
79135
79136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79137   float jresult ;
79138   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79139   float arg2 ;
79140   float result;
79141
79142   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79143   arg2 = (float)jarg2;
79144   {
79145     try {
79146       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79147     } catch (std::out_of_range& e) {
79148       {
79149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79150       };
79151     } catch (std::exception& e) {
79152       {
79153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79154       };
79155     } catch (Dali::DaliException e) {
79156       {
79157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79158       };
79159     } catch (...) {
79160       {
79161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79162       };
79163     }
79164   }
79165
79166   jresult = result;
79167   return jresult;
79168 }
79169
79170
79171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79172   float jresult ;
79173   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79174   float arg2 ;
79175   float arg3 ;
79176   float arg4 ;
79177   float arg5 ;
79178   Dali::Toolkit::ClampState *arg6 = 0 ;
79179   float result;
79180
79181   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79182   arg2 = (float)jarg2;
79183   arg3 = (float)jarg3;
79184   arg4 = (float)jarg4;
79185   arg5 = (float)jarg5;
79186   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79187   if (!arg6) {
79188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79189     return 0;
79190   }
79191   {
79192     try {
79193       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79194     } catch (std::out_of_range& e) {
79195       {
79196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79197       };
79198     } catch (std::exception& e) {
79199       {
79200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79201       };
79202     } catch (Dali::DaliException e) {
79203       {
79204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79205       };
79206     } catch (...) {
79207       {
79208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79209       };
79210     }
79211   }
79212
79213   jresult = result;
79214   return jresult;
79215 }
79216
79217
79218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79219   void * jresult ;
79220   Dali::Toolkit::DefaultRuler *result = 0 ;
79221
79222   {
79223     try {
79224       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79225     } catch (std::out_of_range& e) {
79226       {
79227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79228       };
79229     } catch (std::exception& e) {
79230       {
79231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79232       };
79233     } catch (Dali::DaliException e) {
79234       {
79235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79236       };
79237     } catch (...) {
79238       {
79239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79240       };
79241     }
79242   }
79243
79244   jresult = (void *)result;
79245   return jresult;
79246 }
79247
79248
79249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79250   float jresult ;
79251   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79252   float arg2 ;
79253   float arg3 ;
79254   float result;
79255
79256   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79257   arg2 = (float)jarg2;
79258   arg3 = (float)jarg3;
79259   {
79260     try {
79261       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79262     } catch (std::out_of_range& e) {
79263       {
79264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79265       };
79266     } catch (std::exception& e) {
79267       {
79268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (Dali::DaliException e) {
79271       {
79272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79273       };
79274     } catch (...) {
79275       {
79276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79277       };
79278     }
79279   }
79280
79281   jresult = result;
79282   return jresult;
79283 }
79284
79285
79286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79287   float jresult ;
79288   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79289   unsigned int arg2 ;
79290   unsigned int *arg3 = 0 ;
79291   bool arg4 ;
79292   float result;
79293
79294   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79295   arg2 = (unsigned int)jarg2;
79296   arg3 = (unsigned int *)jarg3;
79297   arg4 = jarg4 ? true : false;
79298   {
79299     try {
79300       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79301     } catch (std::out_of_range& e) {
79302       {
79303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (std::exception& e) {
79306       {
79307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79308       };
79309     } catch (Dali::DaliException e) {
79310       {
79311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79312       };
79313     } catch (...) {
79314       {
79315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79316       };
79317     }
79318   }
79319
79320   jresult = result;
79321   return jresult;
79322 }
79323
79324
79325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79326   unsigned int jresult ;
79327   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79328   float arg2 ;
79329   bool arg3 ;
79330   unsigned int result;
79331
79332   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79333   arg2 = (float)jarg2;
79334   arg3 = jarg3 ? true : false;
79335   {
79336     try {
79337       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79338     } catch (std::out_of_range& e) {
79339       {
79340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (std::exception& e) {
79343       {
79344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (Dali::DaliException e) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79349       };
79350     } catch (...) {
79351       {
79352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79353       };
79354     }
79355   }
79356
79357   jresult = result;
79358   return jresult;
79359 }
79360
79361
79362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79363   unsigned int jresult ;
79364   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79365   unsigned int result;
79366
79367   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79368   {
79369     try {
79370       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79371     } catch (std::out_of_range& e) {
79372       {
79373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79374       };
79375     } catch (std::exception& e) {
79376       {
79377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79378       };
79379     } catch (Dali::DaliException e) {
79380       {
79381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79382       };
79383     } catch (...) {
79384       {
79385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79386       };
79387     }
79388   }
79389
79390   jresult = result;
79391   return jresult;
79392 }
79393
79394
79395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79396   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79397
79398   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79399   {
79400     try {
79401       delete arg1;
79402     } catch (std::out_of_range& e) {
79403       {
79404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79405       };
79406     } catch (std::exception& e) {
79407       {
79408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79409       };
79410     } catch (Dali::DaliException e) {
79411       {
79412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79413       };
79414     } catch (...) {
79415       {
79416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79417       };
79418     }
79419   }
79420
79421 }
79422
79423
79424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79425   void * jresult ;
79426   float arg1 ;
79427   Dali::Toolkit::FixedRuler *result = 0 ;
79428
79429   arg1 = (float)jarg1;
79430   {
79431     try {
79432       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79433     } catch (std::out_of_range& e) {
79434       {
79435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79436       };
79437     } catch (std::exception& e) {
79438       {
79439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79440       };
79441     } catch (Dali::DaliException e) {
79442       {
79443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79444       };
79445     } catch (...) {
79446       {
79447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79448       };
79449     }
79450   }
79451
79452   jresult = (void *)result;
79453   return jresult;
79454 }
79455
79456
79457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79458   void * jresult ;
79459   Dali::Toolkit::FixedRuler *result = 0 ;
79460
79461   {
79462     try {
79463       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79464     } catch (std::out_of_range& e) {
79465       {
79466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79467       };
79468     } catch (std::exception& e) {
79469       {
79470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79471       };
79472     } catch (Dali::DaliException e) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79475       };
79476     } catch (...) {
79477       {
79478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79479       };
79480     }
79481   }
79482
79483   jresult = (void *)result;
79484   return jresult;
79485 }
79486
79487
79488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79489   float jresult ;
79490   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79491   float arg2 ;
79492   float arg3 ;
79493   float result;
79494
79495   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79496   arg2 = (float)jarg2;
79497   arg3 = (float)jarg3;
79498   {
79499     try {
79500       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (Dali::DaliException e) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79512       };
79513     } catch (...) {
79514       {
79515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79516       };
79517     }
79518   }
79519
79520   jresult = result;
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79526   float jresult ;
79527   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79528   unsigned int arg2 ;
79529   unsigned int *arg3 = 0 ;
79530   bool arg4 ;
79531   float result;
79532
79533   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79534   arg2 = (unsigned int)jarg2;
79535   arg3 = (unsigned int *)jarg3;
79536   arg4 = jarg4 ? true : false;
79537   {
79538     try {
79539       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79540     } catch (std::out_of_range& e) {
79541       {
79542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79543       };
79544     } catch (std::exception& e) {
79545       {
79546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79547       };
79548     } catch (Dali::DaliException e) {
79549       {
79550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79551       };
79552     } catch (...) {
79553       {
79554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79555       };
79556     }
79557   }
79558
79559   jresult = result;
79560   return jresult;
79561 }
79562
79563
79564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79565   unsigned int jresult ;
79566   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79567   float arg2 ;
79568   bool arg3 ;
79569   unsigned int result;
79570
79571   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79572   arg2 = (float)jarg2;
79573   arg3 = jarg3 ? true : false;
79574   {
79575     try {
79576       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79577     } catch (std::out_of_range& e) {
79578       {
79579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (std::exception& e) {
79582       {
79583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79584       };
79585     } catch (Dali::DaliException e) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79588       };
79589     } catch (...) {
79590       {
79591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79592       };
79593     }
79594   }
79595
79596   jresult = result;
79597   return jresult;
79598 }
79599
79600
79601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79602   unsigned int jresult ;
79603   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79604   unsigned int result;
79605
79606   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79607   {
79608     try {
79609       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79610     } catch (std::out_of_range& e) {
79611       {
79612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79613       };
79614     } catch (std::exception& e) {
79615       {
79616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79617       };
79618     } catch (Dali::DaliException e) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79621       };
79622     } catch (...) {
79623       {
79624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79625       };
79626     }
79627   }
79628
79629   jresult = result;
79630   return jresult;
79631 }
79632
79633
79634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79635   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79636
79637   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79638   {
79639     try {
79640       delete arg1;
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79648       };
79649     } catch (Dali::DaliException e) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79652       };
79653     } catch (...) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79656       };
79657     }
79658   }
79659
79660 }
79661
79662
79663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79664   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79665   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79666
79667   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79668   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79669   if (arg1) (arg1)->scale = *arg2;
79670 }
79671
79672
79673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79674   void * jresult ;
79675   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79676   Dali::Toolkit::ClampState2D *result = 0 ;
79677
79678   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79679   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79680   jresult = (void *)result;
79681   return jresult;
79682 }
79683
79684
79685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79686   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79687   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79688
79689   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79690   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79691   if (arg1) (arg1)->position = *arg2;
79692 }
79693
79694
79695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79696   void * jresult ;
79697   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79698   Dali::Toolkit::ClampState2D *result = 0 ;
79699
79700   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79701   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79702   jresult = (void *)result;
79703   return jresult;
79704 }
79705
79706
79707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79708   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79709   Dali::Toolkit::ClampState arg2 ;
79710
79711   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79712   arg2 = (Dali::Toolkit::ClampState)jarg2;
79713   if (arg1) (arg1)->rotation = arg2;
79714 }
79715
79716
79717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79718   int jresult ;
79719   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79720   Dali::Toolkit::ClampState result;
79721
79722   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79723   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79724   jresult = (int)result;
79725   return jresult;
79726 }
79727
79728
79729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79730   void * jresult ;
79731   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79732
79733   {
79734     try {
79735       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79736     } catch (std::out_of_range& e) {
79737       {
79738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79739       };
79740     } catch (std::exception& e) {
79741       {
79742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (Dali::DaliException e) {
79745       {
79746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79747       };
79748     } catch (...) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79751       };
79752     }
79753   }
79754
79755   jresult = (void *)result;
79756   return jresult;
79757 }
79758
79759
79760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79761   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79762
79763   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79764   {
79765     try {
79766       delete arg1;
79767     } catch (std::out_of_range& e) {
79768       {
79769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79770       };
79771     } catch (std::exception& e) {
79772       {
79773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79774       };
79775     } catch (Dali::DaliException e) {
79776       {
79777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79778       };
79779     } catch (...) {
79780       {
79781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79782       };
79783     }
79784   }
79785
79786 }
79787
79788
79789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79790   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79791   Dali::Toolkit::SnapType arg2 ;
79792
79793   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79794   arg2 = (Dali::Toolkit::SnapType)jarg2;
79795   if (arg1) (arg1)->type = arg2;
79796 }
79797
79798
79799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79800   int jresult ;
79801   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79802   Dali::Toolkit::SnapType result;
79803
79804   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79805   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79806   jresult = (int)result;
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79812   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79813   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79814
79815   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79816   arg2 = (Dali::Vector2 *)jarg2;
79817   if (arg1) (arg1)->position = *arg2;
79818 }
79819
79820
79821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79822   void * jresult ;
79823   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79824   Dali::Vector2 *result = 0 ;
79825
79826   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79827   result = (Dali::Vector2 *)& ((arg1)->position);
79828   jresult = (void *)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79834   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79835   float arg2 ;
79836
79837   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79838   arg2 = (float)jarg2;
79839   if (arg1) (arg1)->duration = arg2;
79840 }
79841
79842
79843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79844   float jresult ;
79845   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79846   float result;
79847
79848   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79849   result = (float) ((arg1)->duration);
79850   jresult = result;
79851   return jresult;
79852 }
79853
79854
79855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79856   void * jresult ;
79857   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79858
79859   {
79860     try {
79861       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79862     } catch (std::out_of_range& e) {
79863       {
79864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79865       };
79866     } catch (std::exception& e) {
79867       {
79868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79869       };
79870     } catch (Dali::DaliException e) {
79871       {
79872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79873       };
79874     } catch (...) {
79875       {
79876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79877       };
79878     }
79879   }
79880
79881   jresult = (void *)result;
79882   return jresult;
79883 }
79884
79885
79886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79887   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79888
79889   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79890   {
79891     try {
79892       delete arg1;
79893     } catch (std::out_of_range& e) {
79894       {
79895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79896       };
79897     } catch (std::exception& e) {
79898       {
79899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79900       };
79901     } catch (Dali::DaliException e) {
79902       {
79903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79904       };
79905     } catch (...) {
79906       {
79907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79908       };
79909     }
79910   }
79911
79912 }
79913
79914
79915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79916   int jresult ;
79917   int result;
79918
79919   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79920   jresult = (int)result;
79921   return jresult;
79922 }
79923
79924
79925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79926   int jresult ;
79927   int result;
79928
79929   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79930   jresult = (int)result;
79931   return jresult;
79932 }
79933
79934
79935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79936   int jresult ;
79937   int result;
79938
79939   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79940   jresult = (int)result;
79941   return jresult;
79942 }
79943
79944
79945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79946   int jresult ;
79947   int result;
79948
79949   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79950   jresult = (int)result;
79951   return jresult;
79952 }
79953
79954
79955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79956   int jresult ;
79957   int result;
79958
79959   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79960   jresult = (int)result;
79961   return jresult;
79962 }
79963
79964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79965   int jresult ;
79966   int result;
79967
79968   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79969   jresult = (int)result;
79970   return jresult;
79971 }
79972
79973
79974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79975   int jresult ;
79976   int result;
79977
79978   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79979   jresult = (int)result;
79980   return jresult;
79981 }
79982
79983
79984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79985   int jresult ;
79986   int result;
79987
79988   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79989   jresult = (int)result;
79990   return jresult;
79991 }
79992
79993
79994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79995   int jresult ;
79996   int result;
79997
79998   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79999   jresult = (int)result;
80000   return jresult;
80001 }
80002
80003
80004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80005   int jresult ;
80006   int result;
80007
80008   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80009   jresult = (int)result;
80010   return jresult;
80011 }
80012
80013
80014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80015   int jresult ;
80016   int result;
80017
80018   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80019   jresult = (int)result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80025   int jresult ;
80026   int result;
80027
80028   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80029   jresult = (int)result;
80030   return jresult;
80031 }
80032
80033
80034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80035   int jresult ;
80036   int result;
80037
80038   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80039   jresult = (int)result;
80040   return jresult;
80041 }
80042
80043
80044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80045   int jresult ;
80046   int result;
80047
80048   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80049   jresult = (int)result;
80050   return jresult;
80051 }
80052
80053
80054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80055   int jresult ;
80056   int result;
80057
80058   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80059   jresult = (int)result;
80060   return jresult;
80061 }
80062
80063
80064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80065   int jresult ;
80066   int result;
80067
80068   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80069   jresult = (int)result;
80070   return jresult;
80071 }
80072
80073
80074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80075   int jresult ;
80076   int result;
80077
80078   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80079   jresult = (int)result;
80080   return jresult;
80081 }
80082
80083
80084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80085   int jresult ;
80086   int result;
80087
80088   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80089   jresult = (int)result;
80090   return jresult;
80091 }
80092
80093
80094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80095   int jresult ;
80096   int result;
80097
80098   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80099   jresult = (int)result;
80100   return jresult;
80101 }
80102
80103
80104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80105   int jresult ;
80106   int result;
80107
80108   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80109   jresult = (int)result;
80110   return jresult;
80111 }
80112
80113
80114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80115   int jresult ;
80116   int result;
80117
80118   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80119   jresult = (int)result;
80120   return jresult;
80121 }
80122
80123
80124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80125   int jresult ;
80126   int result;
80127
80128   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80129   jresult = (int)result;
80130   return jresult;
80131 }
80132
80133
80134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80135   int jresult ;
80136   int result;
80137
80138   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80139   jresult = (int)result;
80140   return jresult;
80141 }
80142
80143
80144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80145   int jresult ;
80146   int result;
80147
80148   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80149   jresult = (int)result;
80150   return jresult;
80151 }
80152
80153
80154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80155   int jresult ;
80156   int result;
80157
80158   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80159   jresult = (int)result;
80160   return jresult;
80161 }
80162
80163
80164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80165   int jresult ;
80166   int result;
80167
80168   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80169   jresult = (int)result;
80170   return jresult;
80171 }
80172
80173
80174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80175   void * jresult ;
80176   Dali::Toolkit::ScrollView::Property *result = 0 ;
80177
80178   {
80179     try {
80180       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80181     } catch (std::out_of_range& e) {
80182       {
80183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (std::exception& e) {
80186       {
80187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80188       };
80189     } catch (Dali::DaliException e) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80192       };
80193     } catch (...) {
80194       {
80195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80196       };
80197     }
80198   }
80199
80200   jresult = (void *)result;
80201   return jresult;
80202 }
80203
80204
80205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80206   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80207
80208   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80209   {
80210     try {
80211       delete arg1;
80212     } catch (std::out_of_range& e) {
80213       {
80214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80215       };
80216     } catch (std::exception& e) {
80217       {
80218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80219       };
80220     } catch (Dali::DaliException e) {
80221       {
80222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80223       };
80224     } catch (...) {
80225       {
80226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80227       };
80228     }
80229   }
80230
80231 }
80232
80233
80234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80235   void * jresult ;
80236   Dali::Toolkit::ScrollView *result = 0 ;
80237
80238   {
80239     try {
80240       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80241     } catch (std::out_of_range& e) {
80242       {
80243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80244       };
80245     } catch (std::exception& e) {
80246       {
80247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80248       };
80249     } catch (Dali::DaliException e) {
80250       {
80251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80252       };
80253     } catch (...) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80256       };
80257     }
80258   }
80259
80260   jresult = (void *)result;
80261   return jresult;
80262 }
80263
80264
80265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80266   void * jresult ;
80267   Dali::Toolkit::ScrollView *arg1 = 0 ;
80268   Dali::Toolkit::ScrollView *result = 0 ;
80269
80270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80271   if (!arg1) {
80272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80273     return 0;
80274   }
80275   {
80276     try {
80277       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80278     } catch (std::out_of_range& e) {
80279       {
80280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80281       };
80282     } catch (std::exception& e) {
80283       {
80284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80285       };
80286     } catch (Dali::DaliException e) {
80287       {
80288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80293       };
80294     }
80295   }
80296
80297   jresult = (void *)result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80303   void * jresult ;
80304   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80305   Dali::Toolkit::ScrollView *arg2 = 0 ;
80306   Dali::Toolkit::ScrollView *result = 0 ;
80307
80308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80309   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80310   if (!arg2) {
80311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80312     return 0;
80313   }
80314   {
80315     try {
80316       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80317     } catch (std::out_of_range& e) {
80318       {
80319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (std::exception& e) {
80322       {
80323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80324       };
80325     } catch (Dali::DaliException e) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80328       };
80329     } catch (...) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80332       };
80333     }
80334   }
80335
80336   jresult = (void *)result;
80337   return jresult;
80338 }
80339
80340
80341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80343
80344   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80345   {
80346     try {
80347       delete arg1;
80348     } catch (std::out_of_range& e) {
80349       {
80350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80351       };
80352     } catch (std::exception& e) {
80353       {
80354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80355       };
80356     } catch (Dali::DaliException e) {
80357       {
80358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80359       };
80360     } catch (...) {
80361       {
80362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80363       };
80364     }
80365   }
80366
80367 }
80368
80369
80370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80371   void * jresult ;
80372   Dali::Toolkit::ScrollView result;
80373
80374   {
80375     try {
80376       result = Dali::Toolkit::ScrollView::New();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (Dali::DaliException e) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395
80396   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80402   void * jresult ;
80403   Dali::BaseHandle arg1 ;
80404   Dali::BaseHandle *argp1 ;
80405   Dali::Toolkit::ScrollView result;
80406
80407   argp1 = (Dali::BaseHandle *)jarg1;
80408   if (!argp1) {
80409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80410     return 0;
80411   }
80412   arg1 = *argp1;
80413   {
80414     try {
80415       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80416     } catch (std::out_of_range& e) {
80417       {
80418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80419       };
80420     } catch (std::exception& e) {
80421       {
80422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (Dali::DaliException e) {
80425       {
80426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80427       };
80428     } catch (...) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80431       };
80432     }
80433   }
80434
80435   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80436   return jresult;
80437 }
80438
80439
80440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80441   void * jresult ;
80442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80443   Dali::AlphaFunction result;
80444
80445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80446   {
80447     try {
80448       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80449     } catch (std::out_of_range& e) {
80450       {
80451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80452       };
80453     } catch (std::exception& e) {
80454       {
80455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80456       };
80457     } catch (Dali::DaliException e) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80460       };
80461     } catch (...) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80464       };
80465     }
80466   }
80467
80468   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80469   return jresult;
80470 }
80471
80472
80473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80474   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80475   Dali::AlphaFunction arg2 ;
80476   Dali::AlphaFunction *argp2 ;
80477
80478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80479   argp2 = (Dali::AlphaFunction *)jarg2;
80480   if (!argp2) {
80481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80482     return ;
80483   }
80484   arg2 = *argp2;
80485   {
80486     try {
80487       (arg1)->SetScrollSnapAlphaFunction(arg2);
80488     } catch (std::out_of_range& e) {
80489       {
80490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80491       };
80492     } catch (std::exception& e) {
80493       {
80494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80495       };
80496     } catch (Dali::DaliException e) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80499       };
80500     } catch (...) {
80501       {
80502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80503       };
80504     }
80505   }
80506
80507 }
80508
80509
80510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80511   void * jresult ;
80512   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80513   Dali::AlphaFunction result;
80514
80515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80516   {
80517     try {
80518       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80519     } catch (std::out_of_range& e) {
80520       {
80521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80522       };
80523     } catch (std::exception& e) {
80524       {
80525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80526       };
80527     } catch (Dali::DaliException e) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80530       };
80531     } catch (...) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80534       };
80535     }
80536   }
80537
80538   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80539   return jresult;
80540 }
80541
80542
80543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80545   Dali::AlphaFunction arg2 ;
80546   Dali::AlphaFunction *argp2 ;
80547
80548   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80549   argp2 = (Dali::AlphaFunction *)jarg2;
80550   if (!argp2) {
80551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80552     return ;
80553   }
80554   arg2 = *argp2;
80555   {
80556     try {
80557       (arg1)->SetScrollFlickAlphaFunction(arg2);
80558     } catch (std::out_of_range& e) {
80559       {
80560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80561       };
80562     } catch (std::exception& e) {
80563       {
80564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80565       };
80566     } catch (Dali::DaliException e) {
80567       {
80568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80569       };
80570     } catch (...) {
80571       {
80572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80573       };
80574     }
80575   }
80576
80577 }
80578
80579
80580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80581   float jresult ;
80582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80583   float result;
80584
80585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80586   {
80587     try {
80588       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80589     } catch (std::out_of_range& e) {
80590       {
80591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80592       };
80593     } catch (std::exception& e) {
80594       {
80595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80596       };
80597     } catch (Dali::DaliException e) {
80598       {
80599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80600       };
80601     } catch (...) {
80602       {
80603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80604       };
80605     }
80606   }
80607
80608   jresult = result;
80609   return jresult;
80610 }
80611
80612
80613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80614   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80615   float arg2 ;
80616
80617   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80618   arg2 = (float)jarg2;
80619   {
80620     try {
80621       (arg1)->SetScrollSnapDuration(arg2);
80622     } catch (std::out_of_range& e) {
80623       {
80624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80625       };
80626     } catch (std::exception& e) {
80627       {
80628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80629       };
80630     } catch (Dali::DaliException e) {
80631       {
80632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80633       };
80634     } catch (...) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80637       };
80638     }
80639   }
80640
80641 }
80642
80643
80644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80645   float jresult ;
80646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80647   float result;
80648
80649   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80650   {
80651     try {
80652       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80653     } catch (std::out_of_range& e) {
80654       {
80655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80656       };
80657     } catch (std::exception& e) {
80658       {
80659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80660       };
80661     } catch (Dali::DaliException e) {
80662       {
80663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80664       };
80665     } catch (...) {
80666       {
80667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80668       };
80669     }
80670   }
80671
80672   jresult = result;
80673   return jresult;
80674 }
80675
80676
80677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80679   float arg2 ;
80680
80681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80682   arg2 = (float)jarg2;
80683   {
80684     try {
80685       (arg1)->SetScrollFlickDuration(arg2);
80686     } catch (std::out_of_range& e) {
80687       {
80688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80689       };
80690     } catch (std::exception& e) {
80691       {
80692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80693       };
80694     } catch (Dali::DaliException e) {
80695       {
80696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80697       };
80698     } catch (...) {
80699       {
80700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80701       };
80702     }
80703   }
80704
80705 }
80706
80707
80708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80710   Dali::Toolkit::RulerPtr arg2 ;
80711   Dali::Toolkit::RulerPtr *argp2 ;
80712
80713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80714   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80715   if (!argp2) {
80716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80717     return ;
80718   }
80719   arg2 = *argp2;
80720   {
80721     try {
80722       (arg1)->SetRulerX(arg2);
80723     } catch (std::out_of_range& e) {
80724       {
80725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80726       };
80727     } catch (std::exception& e) {
80728       {
80729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80730       };
80731     } catch (Dali::DaliException e) {
80732       {
80733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80734       };
80735     } catch (...) {
80736       {
80737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80738       };
80739     }
80740   }
80741
80742 }
80743
80744
80745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80747   Dali::Toolkit::RulerPtr arg2 ;
80748   Dali::Toolkit::RulerPtr *argp2 ;
80749
80750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80751   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80752   if (!argp2) {
80753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80754     return ;
80755   }
80756   arg2 = *argp2;
80757   {
80758     try {
80759       (arg1)->SetRulerY(arg2);
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80775       };
80776     }
80777   }
80778
80779 }
80780
80781
80782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80784   bool arg2 ;
80785
80786   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80787   arg2 = jarg2 ? true : false;
80788   {
80789     try {
80790       (arg1)->SetScrollSensitive(arg2);
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80806       };
80807     }
80808   }
80809
80810 }
80811
80812
80813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80815   float arg2 ;
80816   float arg3 ;
80817
80818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80819   arg2 = (float)jarg2;
80820   arg3 = (float)jarg3;
80821   {
80822     try {
80823       (arg1)->SetMaxOvershoot(arg2,arg3);
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (Dali::DaliException e) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80839       };
80840     }
80841   }
80842
80843 }
80844
80845
80846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80848   Dali::AlphaFunction arg2 ;
80849   Dali::AlphaFunction *argp2 ;
80850
80851   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80852   argp2 = (Dali::AlphaFunction *)jarg2;
80853   if (!argp2) {
80854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80855     return ;
80856   }
80857   arg2 = *argp2;
80858   {
80859     try {
80860       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80861     } catch (std::out_of_range& e) {
80862       {
80863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80864       };
80865     } catch (std::exception& e) {
80866       {
80867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80868       };
80869     } catch (Dali::DaliException e) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80872       };
80873     } catch (...) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80876       };
80877     }
80878   }
80879
80880 }
80881
80882
80883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80885   float arg2 ;
80886
80887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80888   arg2 = (float)jarg2;
80889   {
80890     try {
80891       (arg1)->SetSnapOvershootDuration(arg2);
80892     } catch (std::out_of_range& e) {
80893       {
80894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80895       };
80896     } catch (std::exception& e) {
80897       {
80898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80899       };
80900     } catch (Dali::DaliException e) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80903       };
80904     } catch (...) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80907       };
80908     }
80909   }
80910
80911 }
80912
80913
80914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80916   bool arg2 ;
80917
80918   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80919   arg2 = jarg2 ? true : false;
80920   {
80921     try {
80922       (arg1)->SetActorAutoSnap(arg2);
80923     } catch (std::out_of_range& e) {
80924       {
80925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80926       };
80927     } catch (std::exception& e) {
80928       {
80929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80930       };
80931     } catch (Dali::DaliException e) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80934       };
80935     } catch (...) {
80936       {
80937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80938       };
80939     }
80940   }
80941
80942 }
80943
80944
80945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80947   bool arg2 ;
80948
80949   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80950   arg2 = jarg2 ? true : false;
80951   {
80952     try {
80953       (arg1)->SetWrapMode(arg2);
80954     } catch (std::out_of_range& e) {
80955       {
80956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80957       };
80958     } catch (std::exception& e) {
80959       {
80960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80961       };
80962     } catch (Dali::DaliException e) {
80963       {
80964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80965       };
80966     } catch (...) {
80967       {
80968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80969       };
80970     }
80971   }
80972
80973 }
80974
80975
80976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80977   int jresult ;
80978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80979   int result;
80980
80981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80982   {
80983     try {
80984       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80985     } catch (std::out_of_range& e) {
80986       {
80987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80988       };
80989     } catch (std::exception& e) {
80990       {
80991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80992       };
80993     } catch (Dali::DaliException e) {
80994       {
80995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80996       };
80997     } catch (...) {
80998       {
80999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81000       };
81001     }
81002   }
81003
81004   jresult = result;
81005   return jresult;
81006 }
81007
81008
81009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81011   int arg2 ;
81012
81013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81014   arg2 = (int)jarg2;
81015   {
81016     try {
81017       (arg1)->SetScrollUpdateDistance(arg2);
81018     } catch (std::out_of_range& e) {
81019       {
81020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81021       };
81022     } catch (std::exception& e) {
81023       {
81024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81025       };
81026     } catch (Dali::DaliException e) {
81027       {
81028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81029       };
81030     } catch (...) {
81031       {
81032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81033       };
81034     }
81035   }
81036
81037 }
81038
81039
81040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81041   unsigned int jresult ;
81042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81043   bool result;
81044
81045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81046   {
81047     try {
81048       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81056       };
81057     } catch (Dali::DaliException e) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81060       };
81061     } catch (...) {
81062       {
81063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81064       };
81065     }
81066   }
81067
81068   jresult = result;
81069   return jresult;
81070 }
81071
81072
81073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81075   bool arg2 ;
81076
81077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81078   arg2 = jarg2 ? true : false;
81079   {
81080     try {
81081       (arg1)->SetAxisAutoLock(arg2);
81082     } catch (std::out_of_range& e) {
81083       {
81084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81085       };
81086     } catch (std::exception& e) {
81087       {
81088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81089       };
81090     } catch (Dali::DaliException e) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81093       };
81094     } catch (...) {
81095       {
81096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81097       };
81098     }
81099   }
81100
81101 }
81102
81103
81104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81105   float jresult ;
81106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81107   float result;
81108
81109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81110   {
81111     try {
81112       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (Dali::DaliException e) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81128       };
81129     }
81130   }
81131
81132   jresult = result;
81133   return jresult;
81134 }
81135
81136
81137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81138   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81139   float arg2 ;
81140
81141   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81142   arg2 = (float)jarg2;
81143   {
81144     try {
81145       (arg1)->SetAxisAutoLockGradient(arg2);
81146     } catch (std::out_of_range& e) {
81147       {
81148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81149       };
81150     } catch (std::exception& e) {
81151       {
81152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81153       };
81154     } catch (Dali::DaliException e) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81157       };
81158     } catch (...) {
81159       {
81160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81161       };
81162     }
81163   }
81164
81165 }
81166
81167
81168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81169   float jresult ;
81170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81171   float result;
81172
81173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81174   {
81175     try {
81176       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81177     } catch (std::out_of_range& e) {
81178       {
81179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81180       };
81181     } catch (std::exception& e) {
81182       {
81183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81184       };
81185     } catch (Dali::DaliException e) {
81186       {
81187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81188       };
81189     } catch (...) {
81190       {
81191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81192       };
81193     }
81194   }
81195
81196   jresult = result;
81197   return jresult;
81198 }
81199
81200
81201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81203   float arg2 ;
81204
81205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81206   arg2 = (float)jarg2;
81207   {
81208     try {
81209       (arg1)->SetFrictionCoefficient(arg2);
81210     } catch (std::out_of_range& e) {
81211       {
81212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81213       };
81214     } catch (std::exception& e) {
81215       {
81216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81217       };
81218     } catch (Dali::DaliException e) {
81219       {
81220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81221       };
81222     } catch (...) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81225       };
81226     }
81227   }
81228
81229 }
81230
81231
81232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81233   float jresult ;
81234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81235   float result;
81236
81237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81238   {
81239     try {
81240       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81241     } catch (std::out_of_range& e) {
81242       {
81243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81244       };
81245     } catch (std::exception& e) {
81246       {
81247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81248       };
81249     } catch (Dali::DaliException e) {
81250       {
81251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81252       };
81253     } catch (...) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81256       };
81257     }
81258   }
81259
81260   jresult = result;
81261   return jresult;
81262 }
81263
81264
81265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81267   float arg2 ;
81268
81269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81270   arg2 = (float)jarg2;
81271   {
81272     try {
81273       (arg1)->SetFlickSpeedCoefficient(arg2);
81274     } catch (std::out_of_range& e) {
81275       {
81276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81277       };
81278     } catch (std::exception& e) {
81279       {
81280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81281       };
81282     } catch (Dali::DaliException e) {
81283       {
81284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81285       };
81286     } catch (...) {
81287       {
81288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81289       };
81290     }
81291   }
81292
81293 }
81294
81295
81296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81297   void * jresult ;
81298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81299   Dali::Vector2 result;
81300
81301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81302   {
81303     try {
81304       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81305     } catch (std::out_of_range& e) {
81306       {
81307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81308       };
81309     } catch (std::exception& e) {
81310       {
81311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (Dali::DaliException e) {
81314       {
81315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81320       };
81321     }
81322   }
81323
81324   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81325   return jresult;
81326 }
81327
81328
81329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81331   Dali::Vector2 *arg2 = 0 ;
81332
81333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81334   arg2 = (Dali::Vector2 *)jarg2;
81335   if (!arg2) {
81336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81337     return ;
81338   }
81339   {
81340     try {
81341       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81342     } catch (std::out_of_range& e) {
81343       {
81344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81345       };
81346     } catch (std::exception& e) {
81347       {
81348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81349       };
81350     } catch (Dali::DaliException e) {
81351       {
81352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81353       };
81354     } catch (...) {
81355       {
81356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81357       };
81358     }
81359   }
81360
81361 }
81362
81363
81364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81365   float jresult ;
81366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81367   float result;
81368
81369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81370   {
81371     try {
81372       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81373     } catch (std::out_of_range& e) {
81374       {
81375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81376       };
81377     } catch (std::exception& e) {
81378       {
81379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81380       };
81381     } catch (Dali::DaliException e) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81384       };
81385     } catch (...) {
81386       {
81387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81388       };
81389     }
81390   }
81391
81392   jresult = result;
81393   return jresult;
81394 }
81395
81396
81397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81399   float arg2 ;
81400
81401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81402   arg2 = (float)jarg2;
81403   {
81404     try {
81405       (arg1)->SetMinimumSpeedForFlick(arg2);
81406     } catch (std::out_of_range& e) {
81407       {
81408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81409       };
81410     } catch (std::exception& e) {
81411       {
81412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (Dali::DaliException e) {
81415       {
81416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81421       };
81422     }
81423   }
81424
81425 }
81426
81427
81428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81429   float jresult ;
81430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81431   float result;
81432
81433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81434   {
81435     try {
81436       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81437     } catch (std::out_of_range& e) {
81438       {
81439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81440       };
81441     } catch (std::exception& e) {
81442       {
81443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (Dali::DaliException e) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81448       };
81449     } catch (...) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81452       };
81453     }
81454   }
81455
81456   jresult = result;
81457   return jresult;
81458 }
81459
81460
81461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81463   float arg2 ;
81464
81465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81466   arg2 = (float)jarg2;
81467   {
81468     try {
81469       (arg1)->SetMaxFlickSpeed(arg2);
81470     } catch (std::out_of_range& e) {
81471       {
81472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81473       };
81474     } catch (std::exception& e) {
81475       {
81476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81477       };
81478     } catch (Dali::DaliException e) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81481       };
81482     } catch (...) {
81483       {
81484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81485       };
81486     }
81487   }
81488
81489 }
81490
81491
81492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81493   void * jresult ;
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   Dali::Vector2 result;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   {
81499     try {
81500       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81516       };
81517     }
81518   }
81519
81520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81521   return jresult;
81522 }
81523
81524
81525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81527   Dali::Vector2 arg2 ;
81528   Dali::Vector2 *argp2 ;
81529
81530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81531   argp2 = (Dali::Vector2 *)jarg2;
81532   if (!argp2) {
81533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81534     return ;
81535   }
81536   arg2 = *argp2;
81537   {
81538     try {
81539       (arg1)->SetWheelScrollDistanceStep(arg2);
81540     } catch (std::out_of_range& e) {
81541       {
81542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (std::exception& e) {
81545       {
81546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81547       };
81548     } catch (Dali::DaliException e) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81551       };
81552     } catch (...) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81555       };
81556     }
81557   }
81558
81559 }
81560
81561
81562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81563   void * jresult ;
81564   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81565   Dali::Vector2 result;
81566
81567   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81568   {
81569     try {
81570       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (Dali::DaliException e) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81582       };
81583     } catch (...) {
81584       {
81585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81586       };
81587     }
81588   }
81589
81590   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81591   return jresult;
81592 }
81593
81594
81595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81596   unsigned int jresult ;
81597   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81598   unsigned int result;
81599
81600   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81601   {
81602     try {
81603       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81604     } catch (std::out_of_range& e) {
81605       {
81606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81607       };
81608     } catch (std::exception& e) {
81609       {
81610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81611       };
81612     } catch (Dali::DaliException e) {
81613       {
81614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81615       };
81616     } catch (...) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81619       };
81620     }
81621   }
81622
81623   jresult = result;
81624   return jresult;
81625 }
81626
81627
81628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81630   Dali::Vector2 *arg2 = 0 ;
81631
81632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81633   arg2 = (Dali::Vector2 *)jarg2;
81634   if (!arg2) {
81635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81636     return ;
81637   }
81638   {
81639     try {
81640       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81641     } catch (std::out_of_range& e) {
81642       {
81643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81644       };
81645     } catch (std::exception& e) {
81646       {
81647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81648       };
81649     } catch (Dali::DaliException e) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81652       };
81653     } catch (...) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81656       };
81657     }
81658   }
81659
81660 }
81661
81662
81663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81665   Dali::Vector2 *arg2 = 0 ;
81666   float arg3 ;
81667
81668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81669   arg2 = (Dali::Vector2 *)jarg2;
81670   if (!arg2) {
81671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81672     return ;
81673   }
81674   arg3 = (float)jarg3;
81675   {
81676     try {
81677       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81678     } catch (std::out_of_range& e) {
81679       {
81680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (std::exception& e) {
81683       {
81684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (Dali::DaliException e) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81693       };
81694     }
81695   }
81696
81697 }
81698
81699
81700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81702   Dali::Vector2 *arg2 = 0 ;
81703   float arg3 ;
81704   Dali::AlphaFunction arg4 ;
81705   Dali::AlphaFunction *argp4 ;
81706
81707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81708   arg2 = (Dali::Vector2 *)jarg2;
81709   if (!arg2) {
81710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81711     return ;
81712   }
81713   arg3 = (float)jarg3;
81714   argp4 = (Dali::AlphaFunction *)jarg4;
81715   if (!argp4) {
81716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81717     return ;
81718   }
81719   arg4 = *argp4;
81720   {
81721     try {
81722       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81730       };
81731     } catch (Dali::DaliException e) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81734       };
81735     } catch (...) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81738       };
81739     }
81740   }
81741
81742 }
81743
81744
81745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81747   Dali::Vector2 *arg2 = 0 ;
81748   float arg3 ;
81749   Dali::Toolkit::DirectionBias arg4 ;
81750   Dali::Toolkit::DirectionBias arg5 ;
81751
81752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81753   arg2 = (Dali::Vector2 *)jarg2;
81754   if (!arg2) {
81755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81756     return ;
81757   }
81758   arg3 = (float)jarg3;
81759   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81760   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81761   {
81762     try {
81763       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81764     } catch (std::out_of_range& e) {
81765       {
81766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81767       };
81768     } catch (std::exception& e) {
81769       {
81770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81771       };
81772     } catch (Dali::DaliException e) {
81773       {
81774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81775       };
81776     } catch (...) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81779       };
81780     }
81781   }
81782
81783 }
81784
81785
81786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81788   Dali::Vector2 *arg2 = 0 ;
81789   float arg3 ;
81790   Dali::AlphaFunction arg4 ;
81791   Dali::Toolkit::DirectionBias arg5 ;
81792   Dali::Toolkit::DirectionBias arg6 ;
81793   Dali::AlphaFunction *argp4 ;
81794
81795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81796   arg2 = (Dali::Vector2 *)jarg2;
81797   if (!arg2) {
81798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81799     return ;
81800   }
81801   arg3 = (float)jarg3;
81802   argp4 = (Dali::AlphaFunction *)jarg4;
81803   if (!argp4) {
81804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81805     return ;
81806   }
81807   arg4 = *argp4;
81808   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81809   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81810   {
81811     try {
81812       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81813     } catch (std::out_of_range& e) {
81814       {
81815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81816       };
81817     } catch (std::exception& e) {
81818       {
81819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81820       };
81821     } catch (Dali::DaliException e) {
81822       {
81823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81824       };
81825     } catch (...) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81828       };
81829     }
81830   }
81831
81832 }
81833
81834
81835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81837   unsigned int arg2 ;
81838
81839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81840   arg2 = (unsigned int)jarg2;
81841   {
81842     try {
81843       (arg1)->ScrollTo(arg2);
81844     } catch (std::out_of_range& e) {
81845       {
81846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81847       };
81848     } catch (std::exception& e) {
81849       {
81850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81851       };
81852     } catch (Dali::DaliException e) {
81853       {
81854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81855       };
81856     } catch (...) {
81857       {
81858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81859       };
81860     }
81861   }
81862
81863 }
81864
81865
81866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81868   unsigned int arg2 ;
81869   float arg3 ;
81870
81871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81872   arg2 = (unsigned int)jarg2;
81873   arg3 = (float)jarg3;
81874   {
81875     try {
81876       (arg1)->ScrollTo(arg2,arg3);
81877     } catch (std::out_of_range& e) {
81878       {
81879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81880       };
81881     } catch (std::exception& e) {
81882       {
81883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81884       };
81885     } catch (Dali::DaliException e) {
81886       {
81887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81888       };
81889     } catch (...) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81892       };
81893     }
81894   }
81895
81896 }
81897
81898
81899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81900   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81901   unsigned int arg2 ;
81902   float arg3 ;
81903   Dali::Toolkit::DirectionBias arg4 ;
81904
81905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81906   arg2 = (unsigned int)jarg2;
81907   arg3 = (float)jarg3;
81908   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81909   {
81910     try {
81911       (arg1)->ScrollTo(arg2,arg3,arg4);
81912     } catch (std::out_of_range& e) {
81913       {
81914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81915       };
81916     } catch (std::exception& e) {
81917       {
81918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (Dali::DaliException e) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81923       };
81924     } catch (...) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81927       };
81928     }
81929   }
81930
81931 }
81932
81933
81934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81936   Dali::Actor *arg2 = 0 ;
81937
81938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81939   arg2 = (Dali::Actor *)jarg2;
81940   if (!arg2) {
81941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81942     return ;
81943   }
81944   {
81945     try {
81946       (arg1)->ScrollTo(*arg2);
81947     } catch (std::out_of_range& e) {
81948       {
81949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81950       };
81951     } catch (std::exception& e) {
81952       {
81953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81954       };
81955     } catch (Dali::DaliException e) {
81956       {
81957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81958       };
81959     } catch (...) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81962       };
81963     }
81964   }
81965
81966 }
81967
81968
81969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81971   Dali::Actor *arg2 = 0 ;
81972   float arg3 ;
81973
81974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81975   arg2 = (Dali::Actor *)jarg2;
81976   if (!arg2) {
81977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81978     return ;
81979   }
81980   arg3 = (float)jarg3;
81981   {
81982     try {
81983       (arg1)->ScrollTo(*arg2,arg3);
81984     } catch (std::out_of_range& e) {
81985       {
81986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81987       };
81988     } catch (std::exception& e) {
81989       {
81990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81991       };
81992     } catch (Dali::DaliException e) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81995       };
81996     } catch (...) {
81997       {
81998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81999       };
82000     }
82001   }
82002
82003 }
82004
82005
82006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82007   unsigned int jresult ;
82008   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82009   bool result;
82010
82011   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82012   {
82013     try {
82014       result = (bool)(arg1)->ScrollToSnapPoint();
82015     } catch (std::out_of_range& e) {
82016       {
82017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82018       };
82019     } catch (std::exception& e) {
82020       {
82021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82022       };
82023     } catch (Dali::DaliException e) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82026       };
82027     } catch (...) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82030       };
82031     }
82032   }
82033
82034   jresult = result;
82035   return jresult;
82036 }
82037
82038
82039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82040   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82041   Dali::Constraint arg2 ;
82042   Dali::Constraint *argp2 ;
82043
82044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82045   argp2 = (Dali::Constraint *)jarg2;
82046   if (!argp2) {
82047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82048     return ;
82049   }
82050   arg2 = *argp2;
82051   {
82052     try {
82053       (arg1)->ApplyConstraintToChildren(arg2);
82054     } catch (std::out_of_range& e) {
82055       {
82056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82057       };
82058     } catch (std::exception& e) {
82059       {
82060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82061       };
82062     } catch (Dali::DaliException e) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82065       };
82066     } catch (...) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82069       };
82070     }
82071   }
82072
82073 }
82074
82075
82076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82078
82079   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82080   {
82081     try {
82082       (arg1)->RemoveConstraintsFromChildren();
82083     } catch (std::out_of_range& e) {
82084       {
82085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82086       };
82087     } catch (std::exception& e) {
82088       {
82089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82090       };
82091     } catch (Dali::DaliException e) {
82092       {
82093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82094       };
82095     } catch (...) {
82096       {
82097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82098       };
82099     }
82100   }
82101
82102 }
82103
82104
82105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82107   Dali::Toolkit::ScrollViewEffect arg2 ;
82108   Dali::Toolkit::ScrollViewEffect *argp2 ;
82109
82110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82111   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82112   if (!argp2) {
82113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82114     return ;
82115   }
82116   arg2 = *argp2;
82117   {
82118     try {
82119       (arg1)->ApplyEffect(arg2);
82120     } catch (std::out_of_range& e) {
82121       {
82122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82123       };
82124     } catch (std::exception& e) {
82125       {
82126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82127       };
82128     } catch (Dali::DaliException e) {
82129       {
82130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82131       };
82132     } catch (...) {
82133       {
82134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82135       };
82136     }
82137   }
82138
82139 }
82140
82141
82142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82144   Dali::Toolkit::ScrollViewEffect arg2 ;
82145   Dali::Toolkit::ScrollViewEffect *argp2 ;
82146
82147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82148   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82149   if (!argp2) {
82150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82151     return ;
82152   }
82153   arg2 = *argp2;
82154   {
82155     try {
82156       (arg1)->RemoveEffect(arg2);
82157     } catch (std::out_of_range& e) {
82158       {
82159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82160       };
82161     } catch (std::exception& e) {
82162       {
82163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82164       };
82165     } catch (Dali::DaliException e) {
82166       {
82167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82172       };
82173     }
82174   }
82175
82176 }
82177
82178
82179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82181
82182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82183   {
82184     try {
82185       (arg1)->RemoveAllEffects();
82186     } catch (std::out_of_range& e) {
82187       {
82188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82189       };
82190     } catch (std::exception& e) {
82191       {
82192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82193       };
82194     } catch (Dali::DaliException e) {
82195       {
82196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82197       };
82198     } catch (...) {
82199       {
82200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82201       };
82202     }
82203   }
82204
82205 }
82206
82207
82208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82210   Dali::Actor arg2 ;
82211   Dali::Actor *argp2 ;
82212
82213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82214   argp2 = (Dali::Actor *)jarg2;
82215   if (!argp2) {
82216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82217     return ;
82218   }
82219   arg2 = *argp2;
82220   {
82221     try {
82222       (arg1)->BindActor(arg2);
82223     } catch (std::out_of_range& e) {
82224       {
82225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82226       };
82227     } catch (std::exception& e) {
82228       {
82229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82230       };
82231     } catch (Dali::DaliException e) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82234       };
82235     } catch (...) {
82236       {
82237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82238       };
82239     }
82240   }
82241
82242 }
82243
82244
82245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82246   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82247   Dali::Actor arg2 ;
82248   Dali::Actor *argp2 ;
82249
82250   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82251   argp2 = (Dali::Actor *)jarg2;
82252   if (!argp2) {
82253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82254     return ;
82255   }
82256   arg2 = *argp2;
82257   {
82258     try {
82259       (arg1)->UnbindActor(arg2);
82260     } catch (std::out_of_range& e) {
82261       {
82262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82263       };
82264     } catch (std::exception& e) {
82265       {
82266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82267       };
82268     } catch (Dali::DaliException e) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82271       };
82272     } catch (...) {
82273       {
82274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82275       };
82276     }
82277   }
82278
82279 }
82280
82281
82282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82283   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82284   Dali::Radian arg2 ;
82285   Dali::Radian arg3 ;
82286   Dali::Radian *argp2 ;
82287   Dali::Radian *argp3 ;
82288
82289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82290   argp2 = (Dali::Radian *)jarg2;
82291   if (!argp2) {
82292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82293     return ;
82294   }
82295   arg2 = *argp2;
82296   argp3 = (Dali::Radian *)jarg3;
82297   if (!argp3) {
82298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82299     return ;
82300   }
82301   arg3 = *argp3;
82302   {
82303     try {
82304       (arg1)->SetScrollingDirection(arg2,arg3);
82305     } catch (std::out_of_range& e) {
82306       {
82307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82308       };
82309     } catch (std::exception& e) {
82310       {
82311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82312       };
82313     } catch (Dali::DaliException e) {
82314       {
82315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82316       };
82317     } catch (...) {
82318       {
82319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82320       };
82321     }
82322   }
82323
82324 }
82325
82326
82327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82329   Dali::Radian arg2 ;
82330   Dali::Radian *argp2 ;
82331
82332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82333   argp2 = (Dali::Radian *)jarg2;
82334   if (!argp2) {
82335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82336     return ;
82337   }
82338   arg2 = *argp2;
82339   {
82340     try {
82341       (arg1)->SetScrollingDirection(arg2);
82342     } catch (std::out_of_range& e) {
82343       {
82344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82345       };
82346     } catch (std::exception& e) {
82347       {
82348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82349       };
82350     } catch (Dali::DaliException e) {
82351       {
82352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82353       };
82354     } catch (...) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82357       };
82358     }
82359   }
82360
82361 }
82362
82363
82364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82366   Dali::Radian arg2 ;
82367   Dali::Radian *argp2 ;
82368
82369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82370   argp2 = (Dali::Radian *)jarg2;
82371   if (!argp2) {
82372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82373     return ;
82374   }
82375   arg2 = *argp2;
82376   {
82377     try {
82378       (arg1)->RemoveScrollingDirection(arg2);
82379     } catch (std::out_of_range& e) {
82380       {
82381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82382       };
82383     } catch (std::exception& e) {
82384       {
82385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82386       };
82387     } catch (Dali::DaliException e) {
82388       {
82389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82390       };
82391     } catch (...) {
82392       {
82393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82394       };
82395     }
82396   }
82397
82398 }
82399
82400
82401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82402   void * jresult ;
82403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82404   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82405
82406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82407   {
82408     try {
82409       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82410     } catch (std::out_of_range& e) {
82411       {
82412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82413       };
82414     } catch (std::exception& e) {
82415       {
82416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82417       };
82418     } catch (Dali::DaliException e) {
82419       {
82420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82421       };
82422     } catch (...) {
82423       {
82424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82425       };
82426     }
82427   }
82428
82429   jresult = (void *)result;
82430   return jresult;
82431 }
82432
82433
82434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82435   int jresult ;
82436   int result;
82437
82438   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82439   jresult = (int)result;
82440   return jresult;
82441 }
82442
82443
82444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82445   int jresult ;
82446   int result;
82447
82448   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82449   jresult = (int)result;
82450   return jresult;
82451 }
82452
82453
82454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82455   int jresult ;
82456   int result;
82457
82458   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82459   jresult = (int)result;
82460   return jresult;
82461 }
82462
82463
82464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82465   int jresult ;
82466   int result;
82467
82468   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82469   jresult = (int)result;
82470   return jresult;
82471 }
82472
82473
82474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82475   int jresult ;
82476   int result;
82477
82478   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82479   jresult = (int)result;
82480   return jresult;
82481 }
82482
82483
82484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82485   void * jresult ;
82486   Dali::Toolkit::TableView::Property *result = 0 ;
82487
82488   {
82489     try {
82490       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82491     } catch (std::out_of_range& e) {
82492       {
82493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82494       };
82495     } catch (std::exception& e) {
82496       {
82497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82498       };
82499     } catch (Dali::DaliException e) {
82500       {
82501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82502       };
82503     } catch (...) {
82504       {
82505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82506       };
82507     }
82508   }
82509
82510   jresult = (void *)result;
82511   return jresult;
82512 }
82513
82514
82515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82516   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82517
82518   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82519   {
82520     try {
82521       delete arg1;
82522     } catch (std::out_of_range& e) {
82523       {
82524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82525       };
82526     } catch (std::exception& e) {
82527       {
82528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82529       };
82530     } catch (Dali::DaliException e) {
82531       {
82532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82533       };
82534     } catch (...) {
82535       {
82536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82537       };
82538     }
82539   }
82540
82541 }
82542
82543
82544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82545   int jresult ;
82546   int result;
82547
82548   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82549   jresult = (int)result;
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82555   int jresult ;
82556   int result;
82557
82558   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82559   jresult = (int)result;
82560   return jresult;
82561 }
82562
82563
82564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82565   int jresult ;
82566   int result;
82567
82568   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82569   jresult = (int)result;
82570   return jresult;
82571 }
82572
82573
82574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82575   int jresult ;
82576   int result;
82577
82578   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82579   jresult = (int)result;
82580   return jresult;
82581 }
82582
82583
82584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82585   int jresult ;
82586   int result;
82587
82588   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82589   jresult = (int)result;
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82595   void * jresult ;
82596   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82597
82598   {
82599     try {
82600       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82601     } catch (std::out_of_range& e) {
82602       {
82603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82604       };
82605     } catch (std::exception& e) {
82606       {
82607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82608       };
82609     } catch (Dali::DaliException e) {
82610       {
82611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82612       };
82613     } catch (...) {
82614       {
82615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82616       };
82617     }
82618   }
82619
82620   jresult = (void *)result;
82621   return jresult;
82622 }
82623
82624
82625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82626   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82627
82628   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82629   {
82630     try {
82631       delete arg1;
82632     } catch (std::out_of_range& e) {
82633       {
82634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82635       };
82636     } catch (std::exception& e) {
82637       {
82638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82639       };
82640     } catch (Dali::DaliException e) {
82641       {
82642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82643       };
82644     } catch (...) {
82645       {
82646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82647       };
82648     }
82649   }
82650
82651 }
82652
82653
82654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82655   void * jresult ;
82656   unsigned int arg1 ;
82657   unsigned int arg2 ;
82658   unsigned int arg3 ;
82659   unsigned int arg4 ;
82660   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82661
82662   arg1 = (unsigned int)jarg1;
82663   arg2 = (unsigned int)jarg2;
82664   arg3 = (unsigned int)jarg3;
82665   arg4 = (unsigned int)jarg4;
82666   {
82667     try {
82668       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82669     } catch (std::out_of_range& e) {
82670       {
82671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82672       };
82673     } catch (std::exception& e) {
82674       {
82675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82676       };
82677     } catch (Dali::DaliException e) {
82678       {
82679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82680       };
82681     } catch (...) {
82682       {
82683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82684       };
82685     }
82686   }
82687
82688   jresult = (void *)result;
82689   return jresult;
82690 }
82691
82692
82693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82694   void * jresult ;
82695   unsigned int arg1 ;
82696   unsigned int arg2 ;
82697   unsigned int arg3 ;
82698   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82699
82700   arg1 = (unsigned int)jarg1;
82701   arg2 = (unsigned int)jarg2;
82702   arg3 = (unsigned int)jarg3;
82703   {
82704     try {
82705       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82706     } catch (std::out_of_range& e) {
82707       {
82708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82709       };
82710     } catch (std::exception& e) {
82711       {
82712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82713       };
82714     } catch (Dali::DaliException e) {
82715       {
82716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82717       };
82718     } catch (...) {
82719       {
82720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82721       };
82722     }
82723   }
82724
82725   jresult = (void *)result;
82726   return jresult;
82727 }
82728
82729
82730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82731   void * jresult ;
82732   unsigned int arg1 ;
82733   unsigned int arg2 ;
82734   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82735
82736   arg1 = (unsigned int)jarg1;
82737   arg2 = (unsigned int)jarg2;
82738   {
82739     try {
82740       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82741     } catch (std::out_of_range& e) {
82742       {
82743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82744       };
82745     } catch (std::exception& e) {
82746       {
82747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82748       };
82749     } catch (Dali::DaliException e) {
82750       {
82751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82752       };
82753     } catch (...) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82756       };
82757     }
82758   }
82759
82760   jresult = (void *)result;
82761   return jresult;
82762 }
82763
82764
82765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82766   void * jresult ;
82767   unsigned int arg1 ;
82768   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82769
82770   arg1 = (unsigned int)jarg1;
82771   {
82772     try {
82773       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82774     } catch (std::out_of_range& e) {
82775       {
82776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82777       };
82778     } catch (std::exception& e) {
82779       {
82780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82781       };
82782     } catch (Dali::DaliException e) {
82783       {
82784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82785       };
82786     } catch (...) {
82787       {
82788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82789       };
82790     }
82791   }
82792
82793   jresult = (void *)result;
82794   return jresult;
82795 }
82796
82797
82798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82799   void * jresult ;
82800   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82801
82802   {
82803     try {
82804       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82805     } catch (std::out_of_range& e) {
82806       {
82807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82808       };
82809     } catch (std::exception& e) {
82810       {
82811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82812       };
82813     } catch (Dali::DaliException e) {
82814       {
82815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82816       };
82817     } catch (...) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82820       };
82821     }
82822   }
82823
82824   jresult = (void *)result;
82825   return jresult;
82826 }
82827
82828
82829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82830   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82831   unsigned int arg2 ;
82832
82833   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82834   arg2 = (unsigned int)jarg2;
82835   if (arg1) (arg1)->rowIndex = arg2;
82836 }
82837
82838
82839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82840   unsigned int jresult ;
82841   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82842   unsigned int result;
82843
82844   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82845   result = (unsigned int) ((arg1)->rowIndex);
82846   jresult = result;
82847   return jresult;
82848 }
82849
82850
82851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82852   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82853   unsigned int arg2 ;
82854
82855   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82856   arg2 = (unsigned int)jarg2;
82857   if (arg1) (arg1)->columnIndex = arg2;
82858 }
82859
82860
82861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82862   unsigned int jresult ;
82863   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82864   unsigned int result;
82865
82866   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82867   result = (unsigned int) ((arg1)->columnIndex);
82868   jresult = result;
82869   return jresult;
82870 }
82871
82872
82873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82874   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82875   unsigned int arg2 ;
82876
82877   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82878   arg2 = (unsigned int)jarg2;
82879   if (arg1) (arg1)->rowSpan = arg2;
82880 }
82881
82882
82883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82884   unsigned int jresult ;
82885   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82886   unsigned int result;
82887
82888   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82889   result = (unsigned int) ((arg1)->rowSpan);
82890   jresult = result;
82891   return jresult;
82892 }
82893
82894
82895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82896   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82897   unsigned int arg2 ;
82898
82899   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82900   arg2 = (unsigned int)jarg2;
82901   if (arg1) (arg1)->columnSpan = arg2;
82902 }
82903
82904
82905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82906   unsigned int jresult ;
82907   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82908   unsigned int result;
82909
82910   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82911   result = (unsigned int) ((arg1)->columnSpan);
82912   jresult = result;
82913   return jresult;
82914 }
82915
82916
82917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82918   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82919
82920   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82921   {
82922     try {
82923       delete arg1;
82924     } catch (std::out_of_range& e) {
82925       {
82926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82927       };
82928     } catch (std::exception& e) {
82929       {
82930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82931       };
82932     } catch (Dali::DaliException e) {
82933       {
82934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82935       };
82936     } catch (...) {
82937       {
82938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82939       };
82940     }
82941   }
82942
82943 }
82944
82945
82946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82947   void * jresult ;
82948   Dali::Toolkit::TableView *result = 0 ;
82949
82950   {
82951     try {
82952       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82953     } catch (std::out_of_range& e) {
82954       {
82955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82956       };
82957     } catch (std::exception& e) {
82958       {
82959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82960       };
82961     } catch (Dali::DaliException e) {
82962       {
82963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82964       };
82965     } catch (...) {
82966       {
82967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82968       };
82969     }
82970   }
82971
82972   jresult = (void *)result;
82973   return jresult;
82974 }
82975
82976
82977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82978   void * jresult ;
82979   Dali::Toolkit::TableView *arg1 = 0 ;
82980   Dali::Toolkit::TableView *result = 0 ;
82981
82982   arg1 = (Dali::Toolkit::TableView *)jarg1;
82983   if (!arg1) {
82984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82985     return 0;
82986   }
82987   {
82988     try {
82989       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82990     } catch (std::out_of_range& e) {
82991       {
82992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82993       };
82994     } catch (std::exception& e) {
82995       {
82996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82997       };
82998     } catch (Dali::DaliException e) {
82999       {
83000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83001       };
83002     } catch (...) {
83003       {
83004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83005       };
83006     }
83007   }
83008
83009   jresult = (void *)result;
83010   return jresult;
83011 }
83012
83013
83014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83015   void * jresult ;
83016   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83017   Dali::Toolkit::TableView *arg2 = 0 ;
83018   Dali::Toolkit::TableView *result = 0 ;
83019
83020   arg1 = (Dali::Toolkit::TableView *)jarg1;
83021   arg2 = (Dali::Toolkit::TableView *)jarg2;
83022   if (!arg2) {
83023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83024     return 0;
83025   }
83026   {
83027     try {
83028       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83029     } catch (std::out_of_range& e) {
83030       {
83031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83032       };
83033     } catch (std::exception& e) {
83034       {
83035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83036       };
83037     } catch (Dali::DaliException e) {
83038       {
83039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83040       };
83041     } catch (...) {
83042       {
83043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83044       };
83045     }
83046   }
83047
83048   jresult = (void *)result;
83049   return jresult;
83050 }
83051
83052
83053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83054   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83055
83056   arg1 = (Dali::Toolkit::TableView *)jarg1;
83057   {
83058     try {
83059       delete arg1;
83060     } catch (std::out_of_range& e) {
83061       {
83062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83063       };
83064     } catch (std::exception& e) {
83065       {
83066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83067       };
83068     } catch (Dali::DaliException e) {
83069       {
83070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83075       };
83076     }
83077   }
83078
83079 }
83080
83081
83082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83083   void * jresult ;
83084   unsigned int arg1 ;
83085   unsigned int arg2 ;
83086   Dali::Toolkit::TableView result;
83087
83088   arg1 = (unsigned int)jarg1;
83089   arg2 = (unsigned int)jarg2;
83090   {
83091     try {
83092       result = Dali::Toolkit::TableView::New(arg1,arg2);
83093     } catch (std::out_of_range& e) {
83094       {
83095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (std::exception& e) {
83098       {
83099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83100       };
83101     } catch (Dali::DaliException e) {
83102       {
83103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83104       };
83105     } catch (...) {
83106       {
83107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83108       };
83109     }
83110   }
83111
83112   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83113   return jresult;
83114 }
83115
83116
83117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83118   void * jresult ;
83119   Dali::BaseHandle arg1 ;
83120   Dali::BaseHandle *argp1 ;
83121   Dali::Toolkit::TableView result;
83122
83123   argp1 = (Dali::BaseHandle *)jarg1;
83124   if (!argp1) {
83125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83126     return 0;
83127   }
83128   arg1 = *argp1;
83129   {
83130     try {
83131       result = Dali::Toolkit::TableView::DownCast(arg1);
83132     } catch (std::out_of_range& e) {
83133       {
83134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83135       };
83136     } catch (std::exception& e) {
83137       {
83138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83139       };
83140     } catch (Dali::DaliException e) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83143       };
83144     } catch (...) {
83145       {
83146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83147       };
83148     }
83149   }
83150
83151   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83152   return jresult;
83153 }
83154
83155
83156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83157   unsigned int jresult ;
83158   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83159   Dali::Actor arg2 ;
83160   Dali::Toolkit::TableView::CellPosition arg3 ;
83161   Dali::Actor *argp2 ;
83162   Dali::Toolkit::TableView::CellPosition *argp3 ;
83163   bool result;
83164
83165   arg1 = (Dali::Toolkit::TableView *)jarg1;
83166   argp2 = (Dali::Actor *)jarg2;
83167   if (!argp2) {
83168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83169     return 0;
83170   }
83171   arg2 = *argp2;
83172   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83173   if (!argp3) {
83174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83175     return 0;
83176   }
83177   arg3 = *argp3;
83178   {
83179     try {
83180       result = (bool)(arg1)->AddChild(arg2,arg3);
83181     } catch (std::out_of_range& e) {
83182       {
83183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83184       };
83185     } catch (std::exception& e) {
83186       {
83187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (Dali::DaliException e) {
83190       {
83191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83192       };
83193     } catch (...) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83196       };
83197     }
83198   }
83199
83200   jresult = result;
83201   return jresult;
83202 }
83203
83204
83205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83206   void * jresult ;
83207   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83208   Dali::Toolkit::TableView::CellPosition arg2 ;
83209   Dali::Toolkit::TableView::CellPosition *argp2 ;
83210   Dali::Actor result;
83211
83212   arg1 = (Dali::Toolkit::TableView *)jarg1;
83213   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83214   if (!argp2) {
83215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83216     return 0;
83217   }
83218   arg2 = *argp2;
83219   {
83220     try {
83221       result = (arg1)->GetChildAt(arg2);
83222     } catch (std::out_of_range& e) {
83223       {
83224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83225       };
83226     } catch (std::exception& e) {
83227       {
83228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83229       };
83230     } catch (Dali::DaliException e) {
83231       {
83232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83233       };
83234     } catch (...) {
83235       {
83236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83237       };
83238     }
83239   }
83240
83241   jresult = new Dali::Actor((const Dali::Actor &)result);
83242   return jresult;
83243 }
83244
83245
83246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83247   void * jresult ;
83248   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83249   Dali::Toolkit::TableView::CellPosition arg2 ;
83250   Dali::Toolkit::TableView::CellPosition *argp2 ;
83251   Dali::Actor result;
83252
83253   arg1 = (Dali::Toolkit::TableView *)jarg1;
83254   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83255   if (!argp2) {
83256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83257     return 0;
83258   }
83259   arg2 = *argp2;
83260   {
83261     try {
83262       result = (arg1)->RemoveChildAt(arg2);
83263     } catch (std::out_of_range& e) {
83264       {
83265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83266       };
83267     } catch (std::exception& e) {
83268       {
83269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83270       };
83271     } catch (Dali::DaliException e) {
83272       {
83273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83274       };
83275     } catch (...) {
83276       {
83277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83278       };
83279     }
83280   }
83281
83282   jresult = new Dali::Actor((const Dali::Actor &)result);
83283   return jresult;
83284 }
83285
83286
83287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83288   unsigned int jresult ;
83289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83290   Dali::Actor arg2 ;
83291   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83292   Dali::Actor *argp2 ;
83293   bool result;
83294
83295   arg1 = (Dali::Toolkit::TableView *)jarg1;
83296   argp2 = (Dali::Actor *)jarg2;
83297   if (!argp2) {
83298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83299     return 0;
83300   }
83301   arg2 = *argp2;
83302   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83303   if (!arg3) {
83304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83305     return 0;
83306   }
83307   {
83308     try {
83309       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83310     } catch (std::out_of_range& e) {
83311       {
83312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83313       };
83314     } catch (std::exception& e) {
83315       {
83316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83317       };
83318     } catch (Dali::DaliException e) {
83319       {
83320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83321       };
83322     } catch (...) {
83323       {
83324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83325       };
83326     }
83327   }
83328
83329   jresult = result;
83330   return jresult;
83331 }
83332
83333
83334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83336   unsigned int arg2 ;
83337
83338   arg1 = (Dali::Toolkit::TableView *)jarg1;
83339   arg2 = (unsigned int)jarg2;
83340   {
83341     try {
83342       (arg1)->InsertRow(arg2);
83343     } catch (std::out_of_range& e) {
83344       {
83345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83346       };
83347     } catch (std::exception& e) {
83348       {
83349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83350       };
83351     } catch (Dali::DaliException e) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83354       };
83355     } catch (...) {
83356       {
83357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83358       };
83359     }
83360   }
83361
83362 }
83363
83364
83365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83367   unsigned int arg2 ;
83368
83369   arg1 = (Dali::Toolkit::TableView *)jarg1;
83370   arg2 = (unsigned int)jarg2;
83371   {
83372     try {
83373       (arg1)->DeleteRow(arg2);
83374     } catch (std::out_of_range& e) {
83375       {
83376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83377       };
83378     } catch (std::exception& e) {
83379       {
83380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83381       };
83382     } catch (Dali::DaliException e) {
83383       {
83384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83385       };
83386     } catch (...) {
83387       {
83388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83389       };
83390     }
83391   }
83392
83393 }
83394
83395
83396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83397   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83398   unsigned int arg2 ;
83399   std::vector< Dali::Actor > *arg3 = 0 ;
83400
83401   arg1 = (Dali::Toolkit::TableView *)jarg1;
83402   arg2 = (unsigned int)jarg2;
83403   arg3 = (std::vector< Dali::Actor > *)jarg3;
83404   if (!arg3) {
83405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83406     return ;
83407   }
83408   {
83409     try {
83410       (arg1)->DeleteRow(arg2,*arg3);
83411     } catch (std::out_of_range& e) {
83412       {
83413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83414       };
83415     } catch (std::exception& e) {
83416       {
83417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83418       };
83419     } catch (Dali::DaliException e) {
83420       {
83421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83422       };
83423     } catch (...) {
83424       {
83425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83426       };
83427     }
83428   }
83429
83430 }
83431
83432
83433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83434   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83435   unsigned int arg2 ;
83436
83437   arg1 = (Dali::Toolkit::TableView *)jarg1;
83438   arg2 = (unsigned int)jarg2;
83439   {
83440     try {
83441       (arg1)->InsertColumn(arg2);
83442     } catch (std::out_of_range& e) {
83443       {
83444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83445       };
83446     } catch (std::exception& e) {
83447       {
83448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83449       };
83450     } catch (Dali::DaliException e) {
83451       {
83452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83453       };
83454     } catch (...) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83457       };
83458     }
83459   }
83460
83461 }
83462
83463
83464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83465   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83466   unsigned int arg2 ;
83467
83468   arg1 = (Dali::Toolkit::TableView *)jarg1;
83469   arg2 = (unsigned int)jarg2;
83470   {
83471     try {
83472       (arg1)->DeleteColumn(arg2);
83473     } catch (std::out_of_range& e) {
83474       {
83475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83476       };
83477     } catch (std::exception& e) {
83478       {
83479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83480       };
83481     } catch (Dali::DaliException e) {
83482       {
83483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83484       };
83485     } catch (...) {
83486       {
83487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83488       };
83489     }
83490   }
83491
83492 }
83493
83494
83495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83496   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83497   unsigned int arg2 ;
83498   std::vector< Dali::Actor > *arg3 = 0 ;
83499
83500   arg1 = (Dali::Toolkit::TableView *)jarg1;
83501   arg2 = (unsigned int)jarg2;
83502   arg3 = (std::vector< Dali::Actor > *)jarg3;
83503   if (!arg3) {
83504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83505     return ;
83506   }
83507   {
83508     try {
83509       (arg1)->DeleteColumn(arg2,*arg3);
83510     } catch (std::out_of_range& e) {
83511       {
83512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83513       };
83514     } catch (std::exception& e) {
83515       {
83516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83517       };
83518     } catch (Dali::DaliException e) {
83519       {
83520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83521       };
83522     } catch (...) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83525       };
83526     }
83527   }
83528
83529 }
83530
83531
83532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83534   unsigned int arg2 ;
83535   unsigned int arg3 ;
83536
83537   arg1 = (Dali::Toolkit::TableView *)jarg1;
83538   arg2 = (unsigned int)jarg2;
83539   arg3 = (unsigned int)jarg3;
83540   {
83541     try {
83542       (arg1)->Resize(arg2,arg3);
83543     } catch (std::out_of_range& e) {
83544       {
83545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83546       };
83547     } catch (std::exception& e) {
83548       {
83549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (Dali::DaliException e) {
83552       {
83553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83554       };
83555     } catch (...) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83558       };
83559     }
83560   }
83561
83562 }
83563
83564
83565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83566   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83567   unsigned int arg2 ;
83568   unsigned int arg3 ;
83569   std::vector< Dali::Actor > *arg4 = 0 ;
83570
83571   arg1 = (Dali::Toolkit::TableView *)jarg1;
83572   arg2 = (unsigned int)jarg2;
83573   arg3 = (unsigned int)jarg3;
83574   arg4 = (std::vector< Dali::Actor > *)jarg4;
83575   if (!arg4) {
83576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83577     return ;
83578   }
83579   {
83580     try {
83581       (arg1)->Resize(arg2,arg3,*arg4);
83582     } catch (std::out_of_range& e) {
83583       {
83584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83585       };
83586     } catch (std::exception& e) {
83587       {
83588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83589       };
83590     } catch (Dali::DaliException e) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83593       };
83594     } catch (...) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83597       };
83598     }
83599   }
83600
83601 }
83602
83603
83604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83605   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83606   Dali::Size arg2 ;
83607   Dali::Size *argp2 ;
83608
83609   arg1 = (Dali::Toolkit::TableView *)jarg1;
83610   argp2 = (Dali::Size *)jarg2;
83611   if (!argp2) {
83612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83613     return ;
83614   }
83615   arg2 = *argp2;
83616   {
83617     try {
83618       (arg1)->SetCellPadding(arg2);
83619     } catch (std::out_of_range& e) {
83620       {
83621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83622       };
83623     } catch (std::exception& e) {
83624       {
83625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83626       };
83627     } catch (Dali::DaliException e) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83630       };
83631     } catch (...) {
83632       {
83633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83634       };
83635     }
83636   }
83637
83638 }
83639
83640
83641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83642   void * jresult ;
83643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83644   Dali::Size result;
83645
83646   arg1 = (Dali::Toolkit::TableView *)jarg1;
83647   {
83648     try {
83649       result = (arg1)->GetCellPadding();
83650     } catch (std::out_of_range& e) {
83651       {
83652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83653       };
83654     } catch (std::exception& e) {
83655       {
83656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83657       };
83658     } catch (Dali::DaliException e) {
83659       {
83660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83661       };
83662     } catch (...) {
83663       {
83664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83665       };
83666     }
83667   }
83668
83669   jresult = new Dali::Size((const Dali::Size &)result);
83670   return jresult;
83671 }
83672
83673
83674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83675   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83676   unsigned int arg2 ;
83677
83678   arg1 = (Dali::Toolkit::TableView *)jarg1;
83679   arg2 = (unsigned int)jarg2;
83680   {
83681     try {
83682       (arg1)->SetFitHeight(arg2);
83683     } catch (std::out_of_range& e) {
83684       {
83685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83686       };
83687     } catch (std::exception& e) {
83688       {
83689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83690       };
83691     } catch (Dali::DaliException e) {
83692       {
83693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83694       };
83695     } catch (...) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83698       };
83699     }
83700   }
83701
83702 }
83703
83704
83705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83706   unsigned int jresult ;
83707   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83708   unsigned int arg2 ;
83709   bool result;
83710
83711   arg1 = (Dali::Toolkit::TableView *)jarg1;
83712   arg2 = (unsigned int)jarg2;
83713   {
83714     try {
83715       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83716     } catch (std::out_of_range& e) {
83717       {
83718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83719       };
83720     } catch (std::exception& e) {
83721       {
83722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83723       };
83724     } catch (Dali::DaliException e) {
83725       {
83726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83727       };
83728     } catch (...) {
83729       {
83730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83731       };
83732     }
83733   }
83734
83735   jresult = result;
83736   return jresult;
83737 }
83738
83739
83740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83741   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83742   unsigned int arg2 ;
83743
83744   arg1 = (Dali::Toolkit::TableView *)jarg1;
83745   arg2 = (unsigned int)jarg2;
83746   {
83747     try {
83748       (arg1)->SetFitWidth(arg2);
83749     } catch (std::out_of_range& e) {
83750       {
83751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83752       };
83753     } catch (std::exception& e) {
83754       {
83755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83756       };
83757     } catch (Dali::DaliException e) {
83758       {
83759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83760       };
83761     } catch (...) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83764       };
83765     }
83766   }
83767
83768 }
83769
83770
83771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83772   unsigned int jresult ;
83773   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83774   unsigned int arg2 ;
83775   bool result;
83776
83777   arg1 = (Dali::Toolkit::TableView *)jarg1;
83778   arg2 = (unsigned int)jarg2;
83779   {
83780     try {
83781       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83782     } catch (std::out_of_range& e) {
83783       {
83784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83785       };
83786     } catch (std::exception& e) {
83787       {
83788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83789       };
83790     } catch (Dali::DaliException e) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83793       };
83794     } catch (...) {
83795       {
83796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83797       };
83798     }
83799   }
83800
83801   jresult = result;
83802   return jresult;
83803 }
83804
83805
83806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83807   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83808   unsigned int arg2 ;
83809   float arg3 ;
83810
83811   arg1 = (Dali::Toolkit::TableView *)jarg1;
83812   arg2 = (unsigned int)jarg2;
83813   arg3 = (float)jarg3;
83814   {
83815     try {
83816       (arg1)->SetFixedHeight(arg2,arg3);
83817     } catch (std::out_of_range& e) {
83818       {
83819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83820       };
83821     } catch (std::exception& e) {
83822       {
83823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (Dali::DaliException e) {
83826       {
83827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83828       };
83829     } catch (...) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83832       };
83833     }
83834   }
83835
83836 }
83837
83838
83839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83840   float jresult ;
83841   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83842   unsigned int arg2 ;
83843   float result;
83844
83845   arg1 = (Dali::Toolkit::TableView *)jarg1;
83846   arg2 = (unsigned int)jarg2;
83847   {
83848     try {
83849       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83850     } catch (std::out_of_range& e) {
83851       {
83852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83853       };
83854     } catch (std::exception& e) {
83855       {
83856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83857       };
83858     } catch (Dali::DaliException e) {
83859       {
83860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83861       };
83862     } catch (...) {
83863       {
83864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83865       };
83866     }
83867   }
83868
83869   jresult = result;
83870   return jresult;
83871 }
83872
83873
83874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83875   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83876   unsigned int arg2 ;
83877   float arg3 ;
83878
83879   arg1 = (Dali::Toolkit::TableView *)jarg1;
83880   arg2 = (unsigned int)jarg2;
83881   arg3 = (float)jarg3;
83882   {
83883     try {
83884       (arg1)->SetRelativeHeight(arg2,arg3);
83885     } catch (std::out_of_range& e) {
83886       {
83887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83888       };
83889     } catch (std::exception& e) {
83890       {
83891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83892       };
83893     } catch (Dali::DaliException e) {
83894       {
83895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83896       };
83897     } catch (...) {
83898       {
83899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83900       };
83901     }
83902   }
83903
83904 }
83905
83906
83907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83908   float jresult ;
83909   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83910   unsigned int arg2 ;
83911   float result;
83912
83913   arg1 = (Dali::Toolkit::TableView *)jarg1;
83914   arg2 = (unsigned int)jarg2;
83915   {
83916     try {
83917       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83918     } catch (std::out_of_range& e) {
83919       {
83920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83921       };
83922     } catch (std::exception& e) {
83923       {
83924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83925       };
83926     } catch (Dali::DaliException e) {
83927       {
83928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83929       };
83930     } catch (...) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83933       };
83934     }
83935   }
83936
83937   jresult = result;
83938   return jresult;
83939 }
83940
83941
83942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83943   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83944   unsigned int arg2 ;
83945   float arg3 ;
83946
83947   arg1 = (Dali::Toolkit::TableView *)jarg1;
83948   arg2 = (unsigned int)jarg2;
83949   arg3 = (float)jarg3;
83950   {
83951     try {
83952       (arg1)->SetFixedWidth(arg2,arg3);
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83960       };
83961     } catch (Dali::DaliException e) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83964       };
83965     } catch (...) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83968       };
83969     }
83970   }
83971
83972 }
83973
83974
83975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83976   float jresult ;
83977   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83978   unsigned int arg2 ;
83979   float result;
83980
83981   arg1 = (Dali::Toolkit::TableView *)jarg1;
83982   arg2 = (unsigned int)jarg2;
83983   {
83984     try {
83985       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83986     } catch (std::out_of_range& e) {
83987       {
83988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83989       };
83990     } catch (std::exception& e) {
83991       {
83992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83993       };
83994     } catch (Dali::DaliException e) {
83995       {
83996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83997       };
83998     } catch (...) {
83999       {
84000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84001       };
84002     }
84003   }
84004
84005   jresult = result;
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84011   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84012   unsigned int arg2 ;
84013   float arg3 ;
84014
84015   arg1 = (Dali::Toolkit::TableView *)jarg1;
84016   arg2 = (unsigned int)jarg2;
84017   arg3 = (float)jarg3;
84018   {
84019     try {
84020       (arg1)->SetRelativeWidth(arg2,arg3);
84021     } catch (std::out_of_range& e) {
84022       {
84023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84024       };
84025     } catch (std::exception& e) {
84026       {
84027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84028       };
84029     } catch (Dali::DaliException e) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84032       };
84033     } catch (...) {
84034       {
84035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84036       };
84037     }
84038   }
84039
84040 }
84041
84042
84043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84044   float jresult ;
84045   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84046   unsigned int arg2 ;
84047   float result;
84048
84049   arg1 = (Dali::Toolkit::TableView *)jarg1;
84050   arg2 = (unsigned int)jarg2;
84051   {
84052     try {
84053       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84054     } catch (std::out_of_range& e) {
84055       {
84056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84057       };
84058     } catch (std::exception& e) {
84059       {
84060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (Dali::DaliException e) {
84063       {
84064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84065       };
84066     } catch (...) {
84067       {
84068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84069       };
84070     }
84071   }
84072
84073   jresult = result;
84074   return jresult;
84075 }
84076
84077
84078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84079   unsigned int jresult ;
84080   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84081   unsigned int result;
84082
84083   arg1 = (Dali::Toolkit::TableView *)jarg1;
84084   {
84085     try {
84086       result = (unsigned int)(arg1)->GetRows();
84087     } catch (std::out_of_range& e) {
84088       {
84089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84090       };
84091     } catch (std::exception& e) {
84092       {
84093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (Dali::DaliException e) {
84096       {
84097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84102       };
84103     }
84104   }
84105
84106   jresult = result;
84107   return jresult;
84108 }
84109
84110
84111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84112   unsigned int jresult ;
84113   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84114   unsigned int result;
84115
84116   arg1 = (Dali::Toolkit::TableView *)jarg1;
84117   {
84118     try {
84119       result = (unsigned int)(arg1)->GetColumns();
84120     } catch (std::out_of_range& e) {
84121       {
84122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84123       };
84124     } catch (std::exception& e) {
84125       {
84126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84127       };
84128     } catch (Dali::DaliException e) {
84129       {
84130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84131       };
84132     } catch (...) {
84133       {
84134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84135       };
84136     }
84137   }
84138
84139   jresult = result;
84140   return jresult;
84141 }
84142
84143
84144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84145   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84146   Dali::Toolkit::TableView::CellPosition arg2 ;
84147   Dali::HorizontalAlignment::Type arg3 ;
84148   Dali::VerticalAlignment::Type arg4 ;
84149   Dali::Toolkit::TableView::CellPosition *argp2 ;
84150
84151   arg1 = (Dali::Toolkit::TableView *)jarg1;
84152   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84153   if (!argp2) {
84154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84155     return ;
84156   }
84157   arg2 = *argp2;
84158   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84159   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84160   {
84161     try {
84162       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84163     } catch (std::out_of_range& e) {
84164       {
84165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84166       };
84167     } catch (std::exception& e) {
84168       {
84169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84170       };
84171     } catch (Dali::DaliException e) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84174       };
84175     } catch (...) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84178       };
84179     }
84180   }
84181
84182 }
84183
84184
84185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84186   unsigned int jresult ;
84187   unsigned int result;
84188
84189   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84190   jresult = result;
84191   return jresult;
84192 }
84193
84194
84195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84196   int jresult ;
84197   int result;
84198
84199   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84200   jresult = (int)result;
84201   return jresult;
84202 }
84203
84204
84205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84206   int jresult ;
84207   int result;
84208
84209   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84210   jresult = (int)result;
84211   return jresult;
84212 }
84213
84214
84215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84216   int jresult ;
84217   int result;
84218
84219   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84220   jresult = (int)result;
84221   return jresult;
84222 }
84223
84224
84225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84226   int jresult ;
84227   int result;
84228
84229   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84230   jresult = (int)result;
84231   return jresult;
84232 }
84233
84234
84235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84236   int jresult ;
84237   int result;
84238
84239   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84240   jresult = (int)result;
84241   return jresult;
84242 }
84243
84244
84245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84246   int jresult ;
84247   int result;
84248
84249   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84250   jresult = (int)result;
84251   return jresult;
84252 }
84253
84254
84255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84256   int jresult ;
84257   int result;
84258
84259   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84260   jresult = (int)result;
84261   return jresult;
84262 }
84263
84264
84265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84266   int jresult ;
84267   int result;
84268
84269   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84270   jresult = (int)result;
84271   return jresult;
84272 }
84273
84274
84275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84276   int jresult ;
84277   int result;
84278
84279   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84280   jresult = (int)result;
84281   return jresult;
84282 }
84283
84284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84285   int jresult ;
84286   int result;
84287
84288   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84289   jresult = (int)result;
84290   return jresult;
84291 }
84292
84293
84294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84295   int jresult ;
84296   int result;
84297
84298   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84299   jresult = (int)result;
84300   return jresult;
84301 }
84302
84303
84304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84305   int jresult ;
84306   int result;
84307
84308   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84309   jresult = (int)result;
84310   return jresult;
84311 }
84312
84313
84314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84315   int jresult ;
84316   int result;
84317
84318   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84319   jresult = (int)result;
84320   return jresult;
84321 }
84322
84323
84324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84325   int jresult ;
84326   int result;
84327
84328   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84329   jresult = (int)result;
84330   return jresult;
84331 }
84332
84333
84334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84335   int jresult ;
84336   int result;
84337
84338   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84339   jresult = (int)result;
84340   return jresult;
84341 }
84342
84343
84344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84345   int jresult ;
84346   int result;
84347
84348   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84349   jresult = (int)result;
84350   return jresult;
84351 }
84352
84353
84354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84355   int jresult ;
84356   int result;
84357
84358   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84359   jresult = (int)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84365   int jresult ;
84366   int result;
84367
84368   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84369   jresult = (int)result;
84370   return jresult;
84371 }
84372
84373
84374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84375   int jresult ;
84376   int result;
84377
84378   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84379   jresult = (int)result;
84380   return jresult;
84381 }
84382
84383
84384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84385   int jresult ;
84386   int result;
84387
84388   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84389   jresult = (int)result;
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84395   int jresult ;
84396   int result;
84397
84398   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84399   jresult = (int)result;
84400   return jresult;
84401 }
84402
84403
84404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84405   int jresult ;
84406   int result;
84407
84408   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84409   jresult = (int)result;
84410   return jresult;
84411 }
84412
84413
84414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84415   int jresult ;
84416   int result;
84417
84418   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84419   jresult = (int)result;
84420   return jresult;
84421 }
84422
84423
84424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84425   int jresult ;
84426   int result;
84427
84428   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84429   jresult = (int)result;
84430   return jresult;
84431 }
84432
84433
84434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84435   void * jresult ;
84436   Dali::Toolkit::TextLabel::Property *result = 0 ;
84437
84438   {
84439     try {
84440       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84441     } catch (std::out_of_range& e) {
84442       {
84443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84444       };
84445     } catch (std::exception& e) {
84446       {
84447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84448       };
84449     } catch (Dali::DaliException e) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84452       };
84453     } catch (...) {
84454       {
84455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84456       };
84457     }
84458   }
84459
84460   jresult = (void *)result;
84461   return jresult;
84462 }
84463
84464
84465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84466   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84467
84468   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84469   {
84470     try {
84471       delete arg1;
84472     } catch (std::out_of_range& e) {
84473       {
84474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84475       };
84476     } catch (std::exception& e) {
84477       {
84478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84479       };
84480     } catch (Dali::DaliException e) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84483       };
84484     } catch (...) {
84485       {
84486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84487       };
84488     }
84489   }
84490
84491 }
84492
84493
84494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84495   void * jresult ;
84496   Dali::Toolkit::TextLabel result;
84497
84498   {
84499     try {
84500       result = Dali::Toolkit::TextLabel::New();
84501     } catch (std::out_of_range& e) {
84502       {
84503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84504       };
84505     } catch (std::exception& e) {
84506       {
84507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (Dali::DaliException e) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84512       };
84513     } catch (...) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84516       };
84517     }
84518   }
84519
84520   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84521   return jresult;
84522 }
84523
84524
84525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84526   void * jresult ;
84527   std::string *arg1 = 0 ;
84528   Dali::Toolkit::TextLabel result;
84529
84530   if (!jarg1) {
84531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84532     return 0;
84533   }
84534   std::string arg1_str(jarg1);
84535   arg1 = &arg1_str;
84536   {
84537     try {
84538       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84539     } catch (std::out_of_range& e) {
84540       {
84541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84542       };
84543     } catch (std::exception& e) {
84544       {
84545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (Dali::DaliException e) {
84548       {
84549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84550       };
84551     } catch (...) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84554       };
84555     }
84556   }
84557
84558   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84559
84560   //argout typemap for const std::string&
84561
84562   return jresult;
84563 }
84564
84565
84566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84567   void * jresult ;
84568   Dali::Toolkit::TextLabel *result = 0 ;
84569
84570   {
84571     try {
84572       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84573     } catch (std::out_of_range& e) {
84574       {
84575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (std::exception& e) {
84578       {
84579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84580       };
84581     } catch (Dali::DaliException e) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84584       };
84585     } catch (...) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84588       };
84589     }
84590   }
84591
84592   jresult = (void *)result;
84593   return jresult;
84594 }
84595
84596
84597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84598   void * jresult ;
84599   Dali::Toolkit::TextLabel *arg1 = 0 ;
84600   Dali::Toolkit::TextLabel *result = 0 ;
84601
84602   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84603   if (!arg1) {
84604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84605     return 0;
84606   }
84607   {
84608     try {
84609       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84610     } catch (std::out_of_range& e) {
84611       {
84612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84613       };
84614     } catch (std::exception& e) {
84615       {
84616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84617       };
84618     } catch (Dali::DaliException e) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84621       };
84622     } catch (...) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84625       };
84626     }
84627   }
84628
84629   jresult = (void *)result;
84630   return jresult;
84631 }
84632
84633
84634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84635   void * jresult ;
84636   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84637   Dali::Toolkit::TextLabel *arg2 = 0 ;
84638   Dali::Toolkit::TextLabel *result = 0 ;
84639
84640   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84641   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84642   if (!arg2) {
84643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84644     return 0;
84645   }
84646   {
84647     try {
84648       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84649     } catch (std::out_of_range& e) {
84650       {
84651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (std::exception& e) {
84654       {
84655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84656       };
84657     } catch (Dali::DaliException e) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84660       };
84661     } catch (...) {
84662       {
84663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84664       };
84665     }
84666   }
84667
84668   jresult = (void *)result;
84669   return jresult;
84670 }
84671
84672
84673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84674   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84675
84676   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84677   {
84678     try {
84679       delete arg1;
84680     } catch (std::out_of_range& e) {
84681       {
84682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84683       };
84684     } catch (std::exception& e) {
84685       {
84686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84687       };
84688     } catch (Dali::DaliException e) {
84689       {
84690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84691       };
84692     } catch (...) {
84693       {
84694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84695       };
84696     }
84697   }
84698
84699 }
84700
84701
84702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84703   void * jresult ;
84704   Dali::BaseHandle arg1 ;
84705   Dali::BaseHandle *argp1 ;
84706   Dali::Toolkit::TextLabel result;
84707
84708   argp1 = (Dali::BaseHandle *)jarg1;
84709   if (!argp1) {
84710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84711     return 0;
84712   }
84713   arg1 = *argp1;
84714   {
84715     try {
84716       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84717     } catch (std::out_of_range& e) {
84718       {
84719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84720       };
84721     } catch (std::exception& e) {
84722       {
84723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (Dali::DaliException e) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84728       };
84729     } catch (...) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84732       };
84733     }
84734   }
84735
84736   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84737   return jresult;
84738 }
84739
84740
84741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84742   void * jresult ;
84743   Dali::Toolkit::AccessibilityManager *result = 0 ;
84744
84745   {
84746     try {
84747       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84748     } catch (std::out_of_range& e) {
84749       {
84750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84751       };
84752     } catch (std::exception& e) {
84753       {
84754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84755       };
84756     } catch (Dali::DaliException e) {
84757       {
84758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84759       };
84760     } catch (...) {
84761       {
84762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84763       };
84764     }
84765   }
84766
84767   jresult = (void *)result;
84768   return jresult;
84769 }
84770
84771
84772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84774
84775   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84776   {
84777     try {
84778       delete arg1;
84779     } catch (std::out_of_range& e) {
84780       {
84781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84782       };
84783     } catch (std::exception& e) {
84784       {
84785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84786       };
84787     } catch (Dali::DaliException e) {
84788       {
84789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84790       };
84791     } catch (...) {
84792       {
84793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84794       };
84795     }
84796   }
84797
84798 }
84799
84800
84801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84802   void * jresult ;
84803   Dali::Toolkit::AccessibilityManager result;
84804
84805   {
84806     try {
84807       result = Dali::Toolkit::AccessibilityManager::Get();
84808     } catch (std::out_of_range& e) {
84809       {
84810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (std::exception& e) {
84813       {
84814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84815       };
84816     } catch (Dali::DaliException e) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84819       };
84820     } catch (...) {
84821       {
84822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84823       };
84824     }
84825   }
84826
84827   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84834   Dali::Actor arg2 ;
84835   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84836   std::string *arg4 = 0 ;
84837   Dali::Actor *argp2 ;
84838
84839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84840   argp2 = (Dali::Actor *)jarg2;
84841   if (!argp2) {
84842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84843     return ;
84844   }
84845   arg2 = *argp2;
84846   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84847   if (!jarg4) {
84848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84849     return ;
84850   }
84851   std::string arg4_str(jarg4);
84852   arg4 = &arg4_str;
84853   {
84854     try {
84855       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84856     } catch (std::out_of_range& e) {
84857       {
84858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84859       };
84860     } catch (std::exception& e) {
84861       {
84862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84863       };
84864     } catch (Dali::DaliException e) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84867       };
84868     } catch (...) {
84869       {
84870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84871       };
84872     }
84873   }
84874
84875
84876   //argout typemap for const std::string&
84877
84878 }
84879
84880
84881 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84882   char * jresult ;
84883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84884   Dali::Actor arg2 ;
84885   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84886   Dali::Actor *argp2 ;
84887   std::string result;
84888
84889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84890   argp2 = (Dali::Actor *)jarg2;
84891   if (!argp2) {
84892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84893     return 0;
84894   }
84895   arg2 = *argp2;
84896   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84897   {
84898     try {
84899       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84900     } catch (std::out_of_range& e) {
84901       {
84902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84903       };
84904     } catch (std::exception& e) {
84905       {
84906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84907       };
84908     } catch (Dali::DaliException e) {
84909       {
84910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84911       };
84912     } catch (...) {
84913       {
84914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84915       };
84916     }
84917   }
84918
84919   jresult = SWIG_csharp_string_callback((&result)->c_str());
84920   return jresult;
84921 }
84922
84923
84924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84926   Dali::Actor arg2 ;
84927   unsigned int arg3 ;
84928   Dali::Actor *argp2 ;
84929
84930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84931   argp2 = (Dali::Actor *)jarg2;
84932   if (!argp2) {
84933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84934     return ;
84935   }
84936   arg2 = *argp2;
84937   arg3 = (unsigned int)jarg3;
84938   {
84939     try {
84940       (arg1)->SetFocusOrder(arg2,arg3);
84941     } catch (std::out_of_range& e) {
84942       {
84943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84944       };
84945     } catch (std::exception& e) {
84946       {
84947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84948       };
84949     } catch (Dali::DaliException e) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84952       };
84953     } catch (...) {
84954       {
84955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84956       };
84957     }
84958   }
84959
84960 }
84961
84962
84963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84964   unsigned int jresult ;
84965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84966   Dali::Actor arg2 ;
84967   Dali::Actor *argp2 ;
84968   unsigned int result;
84969
84970   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84971   argp2 = (Dali::Actor *)jarg2;
84972   if (!argp2) {
84973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84974     return 0;
84975   }
84976   arg2 = *argp2;
84977   {
84978     try {
84979       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84980     } catch (std::out_of_range& e) {
84981       {
84982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84983       };
84984     } catch (std::exception& e) {
84985       {
84986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84987       };
84988     } catch (Dali::DaliException e) {
84989       {
84990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84991       };
84992     } catch (...) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84995       };
84996     }
84997   }
84998
84999   jresult = result;
85000   return jresult;
85001 }
85002
85003
85004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85005   unsigned int jresult ;
85006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85007   unsigned int result;
85008
85009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85010   {
85011     try {
85012       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85013     } catch (std::out_of_range& e) {
85014       {
85015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (std::exception& e) {
85018       {
85019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85020       };
85021     } catch (Dali::DaliException e) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85024       };
85025     } catch (...) {
85026       {
85027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85028       };
85029     }
85030   }
85031
85032   jresult = result;
85033   return jresult;
85034 }
85035
85036
85037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85038   void * jresult ;
85039   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85040   unsigned int arg2 ;
85041   Dali::Actor result;
85042
85043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85044   arg2 = (unsigned int)jarg2;
85045   {
85046     try {
85047       result = (arg1)->GetActorByFocusOrder(arg2);
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = new Dali::Actor((const Dali::Actor &)result);
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85073   unsigned int jresult ;
85074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85075   Dali::Actor arg2 ;
85076   Dali::Actor *argp2 ;
85077   bool result;
85078
85079   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85080   argp2 = (Dali::Actor *)jarg2;
85081   if (!argp2) {
85082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85083     return 0;
85084   }
85085   arg2 = *argp2;
85086   {
85087     try {
85088       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85089     } catch (std::out_of_range& e) {
85090       {
85091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85092       };
85093     } catch (std::exception& e) {
85094       {
85095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85096       };
85097     } catch (Dali::DaliException e) {
85098       {
85099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85100       };
85101     } catch (...) {
85102       {
85103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85104       };
85105     }
85106   }
85107
85108   jresult = result;
85109   return jresult;
85110 }
85111
85112
85113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85114   void * jresult ;
85115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85116   Dali::Actor result;
85117
85118   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85119   {
85120     try {
85121       result = (arg1)->GetCurrentFocusActor();
85122     } catch (std::out_of_range& e) {
85123       {
85124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (std::exception& e) {
85127       {
85128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85129       };
85130     } catch (Dali::DaliException e) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85133       };
85134     } catch (...) {
85135       {
85136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85137       };
85138     }
85139   }
85140
85141   jresult = new Dali::Actor((const Dali::Actor &)result);
85142   return jresult;
85143 }
85144
85145
85146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85147   void * jresult ;
85148   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85149   Dali::Actor result;
85150
85151   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85152   {
85153     try {
85154       result = (arg1)->GetCurrentFocusGroup();
85155     } catch (std::out_of_range& e) {
85156       {
85157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (std::exception& e) {
85160       {
85161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85162       };
85163     } catch (Dali::DaliException e) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85166       };
85167     } catch (...) {
85168       {
85169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85170       };
85171     }
85172   }
85173
85174   jresult = new Dali::Actor((const Dali::Actor &)result);
85175   return jresult;
85176 }
85177
85178
85179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85180   unsigned int jresult ;
85181   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85182   unsigned int result;
85183
85184   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85185   {
85186     try {
85187       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85188     } catch (std::out_of_range& e) {
85189       {
85190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85191       };
85192     } catch (std::exception& e) {
85193       {
85194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85195       };
85196     } catch (Dali::DaliException e) {
85197       {
85198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85199       };
85200     } catch (...) {
85201       {
85202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85203       };
85204     }
85205   }
85206
85207   jresult = result;
85208   return jresult;
85209 }
85210
85211
85212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85213   unsigned int jresult ;
85214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85215   bool result;
85216
85217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85218   {
85219     try {
85220       result = (bool)(arg1)->MoveFocusForward();
85221     } catch (std::out_of_range& e) {
85222       {
85223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85224       };
85225     } catch (std::exception& e) {
85226       {
85227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85228       };
85229     } catch (Dali::DaliException e) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85232       };
85233     } catch (...) {
85234       {
85235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85236       };
85237     }
85238   }
85239
85240   jresult = result;
85241   return jresult;
85242 }
85243
85244
85245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85246   unsigned int jresult ;
85247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85248   bool result;
85249
85250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85251   {
85252     try {
85253       result = (bool)(arg1)->MoveFocusBackward();
85254     } catch (std::out_of_range& e) {
85255       {
85256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85257       };
85258     } catch (std::exception& e) {
85259       {
85260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85261       };
85262     } catch (Dali::DaliException e) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85265       };
85266     } catch (...) {
85267       {
85268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85269       };
85270     }
85271   }
85272
85273   jresult = result;
85274   return jresult;
85275 }
85276
85277
85278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85280
85281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85282   {
85283     try {
85284       (arg1)->ClearFocus();
85285     } catch (std::out_of_range& e) {
85286       {
85287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85288       };
85289     } catch (std::exception& e) {
85290       {
85291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85292       };
85293     } catch (Dali::DaliException e) {
85294       {
85295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85296       };
85297     } catch (...) {
85298       {
85299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85300       };
85301     }
85302   }
85303
85304 }
85305
85306
85307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85309
85310   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85311   {
85312     try {
85313       (arg1)->Reset();
85314     } catch (std::out_of_range& e) {
85315       {
85316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85317       };
85318     } catch (std::exception& e) {
85319       {
85320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85321       };
85322     } catch (Dali::DaliException e) {
85323       {
85324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85325       };
85326     } catch (...) {
85327       {
85328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85329       };
85330     }
85331   }
85332
85333 }
85334
85335
85336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85337   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85338   Dali::Actor arg2 ;
85339   bool arg3 ;
85340   Dali::Actor *argp2 ;
85341
85342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85343   argp2 = (Dali::Actor *)jarg2;
85344   if (!argp2) {
85345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85346     return ;
85347   }
85348   arg2 = *argp2;
85349   arg3 = jarg3 ? true : false;
85350   {
85351     try {
85352       (arg1)->SetFocusGroup(arg2,arg3);
85353     } catch (std::out_of_range& e) {
85354       {
85355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85356       };
85357     } catch (std::exception& e) {
85358       {
85359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85360       };
85361     } catch (Dali::DaliException e) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85364       };
85365     } catch (...) {
85366       {
85367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85368       };
85369     }
85370   }
85371
85372 }
85373
85374
85375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85376   unsigned int jresult ;
85377   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85378   Dali::Actor arg2 ;
85379   Dali::Actor *argp2 ;
85380   bool result;
85381
85382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85383   argp2 = (Dali::Actor *)jarg2;
85384   if (!argp2) {
85385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85386     return 0;
85387   }
85388   arg2 = *argp2;
85389   {
85390     try {
85391       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85392     } catch (std::out_of_range& e) {
85393       {
85394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85395       };
85396     } catch (std::exception& e) {
85397       {
85398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85399       };
85400     } catch (Dali::DaliException e) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85403       };
85404     } catch (...) {
85405       {
85406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85407       };
85408     }
85409   }
85410
85411   jresult = result;
85412   return jresult;
85413 }
85414
85415
85416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85417   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85418   bool arg2 ;
85419
85420   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85421   arg2 = jarg2 ? true : false;
85422   {
85423     try {
85424       (arg1)->SetGroupMode(arg2);
85425     } catch (std::out_of_range& e) {
85426       {
85427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85428       };
85429     } catch (std::exception& e) {
85430       {
85431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85432       };
85433     } catch (Dali::DaliException e) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85436       };
85437     } catch (...) {
85438       {
85439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85440       };
85441     }
85442   }
85443
85444 }
85445
85446
85447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85448   unsigned int jresult ;
85449   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85450   bool result;
85451
85452   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85453   {
85454     try {
85455       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85456     } catch (std::out_of_range& e) {
85457       {
85458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (std::exception& e) {
85461       {
85462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85463       };
85464     } catch (Dali::DaliException e) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85467       };
85468     } catch (...) {
85469       {
85470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85471       };
85472     }
85473   }
85474
85475   jresult = result;
85476   return jresult;
85477 }
85478
85479
85480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85481   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85482   bool arg2 ;
85483
85484   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85485   arg2 = jarg2 ? true : false;
85486   {
85487     try {
85488       (arg1)->SetWrapMode(arg2);
85489     } catch (std::out_of_range& e) {
85490       {
85491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85492       };
85493     } catch (std::exception& e) {
85494       {
85495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85496       };
85497     } catch (Dali::DaliException e) {
85498       {
85499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85500       };
85501     } catch (...) {
85502       {
85503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85504       };
85505     }
85506   }
85507
85508 }
85509
85510
85511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85512   unsigned int jresult ;
85513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85514   bool result;
85515
85516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85517   {
85518     try {
85519       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85520     } catch (std::out_of_range& e) {
85521       {
85522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85523       };
85524     } catch (std::exception& e) {
85525       {
85526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85527       };
85528     } catch (Dali::DaliException e) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85535       };
85536     }
85537   }
85538
85539   jresult = result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85545   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85546   Dali::Actor arg2 ;
85547   Dali::Actor *argp2 ;
85548
85549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85550   argp2 = (Dali::Actor *)jarg2;
85551   if (!argp2) {
85552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85553     return ;
85554   }
85555   arg2 = *argp2;
85556   {
85557     try {
85558       (arg1)->SetFocusIndicatorActor(arg2);
85559     } catch (std::out_of_range& e) {
85560       {
85561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85562       };
85563     } catch (std::exception& e) {
85564       {
85565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85566       };
85567     } catch (Dali::DaliException e) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85570       };
85571     } catch (...) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85574       };
85575     }
85576   }
85577
85578 }
85579
85580
85581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85582   void * jresult ;
85583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85584   Dali::Actor result;
85585
85586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85587   {
85588     try {
85589       result = (arg1)->GetFocusIndicatorActor();
85590     } catch (std::out_of_range& e) {
85591       {
85592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85593       };
85594     } catch (std::exception& e) {
85595       {
85596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85597       };
85598     } catch (Dali::DaliException e) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85601       };
85602     } catch (...) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85605       };
85606     }
85607   }
85608
85609   jresult = new Dali::Actor((const Dali::Actor &)result);
85610   return jresult;
85611 }
85612
85613
85614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85615   void * jresult ;
85616   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85617   Dali::Actor arg2 ;
85618   Dali::Actor *argp2 ;
85619   Dali::Actor result;
85620
85621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85622   argp2 = (Dali::Actor *)jarg2;
85623   if (!argp2) {
85624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85625     return 0;
85626   }
85627   arg2 = *argp2;
85628   {
85629     try {
85630       result = (arg1)->GetFocusGroup(arg2);
85631     } catch (std::out_of_range& e) {
85632       {
85633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85634       };
85635     } catch (std::exception& e) {
85636       {
85637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85638       };
85639     } catch (Dali::DaliException e) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85646       };
85647     }
85648   }
85649
85650   jresult = new Dali::Actor((const Dali::Actor &)result);
85651   return jresult;
85652 }
85653
85654
85655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85656   void * jresult ;
85657   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85658   Dali::Vector2 result;
85659
85660   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85661   {
85662     try {
85663       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85664     } catch (std::out_of_range& e) {
85665       {
85666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85667       };
85668     } catch (std::exception& e) {
85669       {
85670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85671       };
85672     } catch (Dali::DaliException e) {
85673       {
85674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85675       };
85676     } catch (...) {
85677       {
85678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85679       };
85680     }
85681   }
85682
85683   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85684   return jresult;
85685 }
85686
85687
85688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85689   void * jresult ;
85690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85691   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85692
85693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85694   {
85695     try {
85696       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85697     } catch (std::out_of_range& e) {
85698       {
85699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85700       };
85701     } catch (std::exception& e) {
85702       {
85703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85704       };
85705     } catch (Dali::DaliException e) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85708       };
85709     } catch (...) {
85710       {
85711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85712       };
85713     }
85714   }
85715
85716   jresult = (void *)result;
85717   return jresult;
85718 }
85719
85720
85721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85722   void * jresult ;
85723   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85724   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85725
85726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85727   {
85728     try {
85729       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85730     } catch (std::out_of_range& e) {
85731       {
85732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85733       };
85734     } catch (std::exception& e) {
85735       {
85736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85737       };
85738     } catch (Dali::DaliException e) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85741       };
85742     } catch (...) {
85743       {
85744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85745       };
85746     }
85747   }
85748
85749   jresult = (void *)result;
85750   return jresult;
85751 }
85752
85753
85754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85755   void * jresult ;
85756   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85757   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85758
85759   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85760   {
85761     try {
85762       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85763     } catch (std::out_of_range& e) {
85764       {
85765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85766       };
85767     } catch (std::exception& e) {
85768       {
85769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85770       };
85771     } catch (Dali::DaliException e) {
85772       {
85773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85774       };
85775     } catch (...) {
85776       {
85777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85778       };
85779     }
85780   }
85781
85782   jresult = (void *)result;
85783   return jresult;
85784 }
85785
85786
85787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85788   void * jresult ;
85789   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85790   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85791
85792   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85793   {
85794     try {
85795       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85796     } catch (std::out_of_range& e) {
85797       {
85798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85799       };
85800     } catch (std::exception& e) {
85801       {
85802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85803       };
85804     } catch (Dali::DaliException e) {
85805       {
85806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85807       };
85808     } catch (...) {
85809       {
85810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85811       };
85812     }
85813   }
85814
85815   jresult = (void *)result;
85816   return jresult;
85817 }
85818
85819
85820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85821   void * jresult ;
85822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85823   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85824
85825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85826   {
85827     try {
85828       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85829     } catch (std::out_of_range& e) {
85830       {
85831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85832       };
85833     } catch (std::exception& e) {
85834       {
85835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85836       };
85837     } catch (Dali::DaliException e) {
85838       {
85839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85840       };
85841     } catch (...) {
85842       {
85843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85844       };
85845     }
85846   }
85847
85848   jresult = (void *)result;
85849   return jresult;
85850 }
85851
85852
85853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85854   void * jresult ;
85855   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85856   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85857
85858   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85859   {
85860     try {
85861       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85862     } catch (std::out_of_range& e) {
85863       {
85864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85865       };
85866     } catch (std::exception& e) {
85867       {
85868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85869       };
85870     } catch (Dali::DaliException e) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85873       };
85874     } catch (...) {
85875       {
85876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85877       };
85878     }
85879   }
85880
85881   jresult = (void *)result;
85882   return jresult;
85883 }
85884
85885
85886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85887   void * jresult ;
85888   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85889   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85890
85891   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85892   {
85893     try {
85894       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85895     } catch (std::out_of_range& e) {
85896       {
85897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (std::exception& e) {
85900       {
85901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85902       };
85903     } catch (Dali::DaliException e) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85906       };
85907     } catch (...) {
85908       {
85909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85910       };
85911     }
85912   }
85913
85914   jresult = (void *)result;
85915   return jresult;
85916 }
85917
85918
85919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85920   void * jresult ;
85921   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85922   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85923
85924   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85925   {
85926     try {
85927       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85928     } catch (std::out_of_range& e) {
85929       {
85930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85931       };
85932     } catch (std::exception& e) {
85933       {
85934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (Dali::DaliException e) {
85937       {
85938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85939       };
85940     } catch (...) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85943       };
85944     }
85945   }
85946
85947   jresult = (void *)result;
85948   return jresult;
85949 }
85950
85951
85952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85953   void * jresult ;
85954   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85955   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85956
85957   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85958   {
85959     try {
85960       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85961     } catch (std::out_of_range& e) {
85962       {
85963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85964       };
85965     } catch (std::exception& e) {
85966       {
85967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85968       };
85969     } catch (Dali::DaliException e) {
85970       {
85971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85972       };
85973     } catch (...) {
85974       {
85975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85976       };
85977     }
85978   }
85979
85980   jresult = (void *)result;
85981   return jresult;
85982 }
85983
85984
85985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85986   void * jresult ;
85987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85988   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85989
85990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85991   {
85992     try {
85993       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85994     } catch (std::out_of_range& e) {
85995       {
85996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85997       };
85998     } catch (std::exception& e) {
85999       {
86000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (Dali::DaliException e) {
86003       {
86004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86005       };
86006     } catch (...) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86009       };
86010     }
86011   }
86012
86013   jresult = (void *)result;
86014   return jresult;
86015 }
86016
86017
86018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86019   void * jresult ;
86020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86021   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86022
86023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86024   {
86025     try {
86026       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86027     } catch (std::out_of_range& e) {
86028       {
86029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86030       };
86031     } catch (std::exception& e) {
86032       {
86033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (Dali::DaliException e) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86038       };
86039     } catch (...) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86042       };
86043     }
86044   }
86045
86046   jresult = (void *)result;
86047   return jresult;
86048 }
86049
86050
86051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86052   void * jresult ;
86053   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86054   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86055
86056   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86057   {
86058     try {
86059       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86060     } catch (std::out_of_range& e) {
86061       {
86062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86063       };
86064     } catch (std::exception& e) {
86065       {
86066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86067       };
86068     } catch (Dali::DaliException e) {
86069       {
86070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86071       };
86072     } catch (...) {
86073       {
86074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86075       };
86076     }
86077   }
86078
86079   jresult = (void *)result;
86080   return jresult;
86081 }
86082
86083
86084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86085   void * jresult ;
86086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86087   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86088
86089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86090   {
86091     try {
86092       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86093     } catch (std::out_of_range& e) {
86094       {
86095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86096       };
86097     } catch (std::exception& e) {
86098       {
86099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86100       };
86101     } catch (Dali::DaliException e) {
86102       {
86103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86104       };
86105     } catch (...) {
86106       {
86107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86108       };
86109     }
86110   }
86111
86112   jresult = (void *)result;
86113   return jresult;
86114 }
86115
86116
86117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86118   void * jresult ;
86119   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86120   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86121
86122   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86123   {
86124     try {
86125       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86126     } catch (std::out_of_range& e) {
86127       {
86128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86129       };
86130     } catch (std::exception& e) {
86131       {
86132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (Dali::DaliException e) {
86135       {
86136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86137       };
86138     } catch (...) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86141       };
86142     }
86143   }
86144
86145   jresult = (void *)result;
86146   return jresult;
86147 }
86148
86149
86150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86151   void * jresult ;
86152   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86153   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86154
86155   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86156   {
86157     try {
86158       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86159     } catch (std::out_of_range& e) {
86160       {
86161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86162       };
86163     } catch (std::exception& e) {
86164       {
86165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86166       };
86167     } catch (Dali::DaliException e) {
86168       {
86169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86170       };
86171     } catch (...) {
86172       {
86173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86174       };
86175     }
86176   }
86177
86178   jresult = (void *)result;
86179   return jresult;
86180 }
86181
86182
86183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86184   void * jresult ;
86185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86186   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86187
86188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86189   {
86190     try {
86191       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86192     } catch (std::out_of_range& e) {
86193       {
86194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86195       };
86196     } catch (std::exception& e) {
86197       {
86198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86199       };
86200     } catch (Dali::DaliException e) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86203       };
86204     } catch (...) {
86205       {
86206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86207       };
86208     }
86209   }
86210
86211   jresult = (void *)result;
86212   return jresult;
86213 }
86214
86215
86216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86217   void * jresult ;
86218   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86219   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86220
86221   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86222   {
86223     try {
86224       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86225     } catch (std::out_of_range& e) {
86226       {
86227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86228       };
86229     } catch (std::exception& e) {
86230       {
86231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86232       };
86233     } catch (Dali::DaliException e) {
86234       {
86235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86236       };
86237     } catch (...) {
86238       {
86239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86240       };
86241     }
86242   }
86243
86244   jresult = (void *)result;
86245   return jresult;
86246 }
86247
86248
86249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86250   void * jresult ;
86251   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86252   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86253
86254   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86255   {
86256     try {
86257       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86258     } catch (std::out_of_range& e) {
86259       {
86260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86261       };
86262     } catch (std::exception& e) {
86263       {
86264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (Dali::DaliException e) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86269       };
86270     } catch (...) {
86271       {
86272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86273       };
86274     }
86275   }
86276
86277   jresult = (void *)result;
86278   return jresult;
86279 }
86280
86281
86282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86283   void * jresult ;
86284   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86285   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86286
86287   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86288   {
86289     try {
86290       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86291     } catch (std::out_of_range& e) {
86292       {
86293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86294       };
86295     } catch (std::exception& e) {
86296       {
86297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (Dali::DaliException e) {
86300       {
86301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86302       };
86303     } catch (...) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86306       };
86307     }
86308   }
86309
86310   jresult = (void *)result;
86311   return jresult;
86312 }
86313
86314
86315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86316   void * jresult ;
86317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86318   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86319
86320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86321   {
86322     try {
86323       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86324     } catch (std::out_of_range& e) {
86325       {
86326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86327       };
86328     } catch (std::exception& e) {
86329       {
86330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (Dali::DaliException e) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86335       };
86336     } catch (...) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86339       };
86340     }
86341   }
86342
86343   jresult = (void *)result;
86344   return jresult;
86345 }
86346
86347
86348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86349   void * jresult ;
86350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86351   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86352
86353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86354   {
86355     try {
86356       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86357     } catch (std::out_of_range& e) {
86358       {
86359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86360       };
86361     } catch (std::exception& e) {
86362       {
86363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86364       };
86365     } catch (Dali::DaliException e) {
86366       {
86367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86368       };
86369     } catch (...) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86372       };
86373     }
86374   }
86375
86376   jresult = (void *)result;
86377   return jresult;
86378 }
86379
86380
86381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86382   void * jresult ;
86383   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86384   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86385
86386   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86387   {
86388     try {
86389       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (Dali::DaliException e) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86401       };
86402     } catch (...) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86405       };
86406     }
86407   }
86408
86409   jresult = (void *)result;
86410   return jresult;
86411 }
86412
86413
86414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86415   void * jresult ;
86416   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86417   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86418
86419   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86420   {
86421     try {
86422       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (Dali::DaliException e) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86434       };
86435     } catch (...) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86438       };
86439     }
86440   }
86441
86442   jresult = (void *)result;
86443   return jresult;
86444 }
86445
86446
86447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86448   void * jresult ;
86449   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86450   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86451
86452   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86453   {
86454     try {
86455       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86463       };
86464     } catch (Dali::DaliException e) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86467       };
86468     } catch (...) {
86469       {
86470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86471       };
86472     }
86473   }
86474
86475   jresult = (void *)result;
86476   return jresult;
86477 }
86478
86479
86480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86481   void * jresult ;
86482   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86483   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86484
86485   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86486   {
86487     try {
86488       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86489     } catch (std::out_of_range& e) {
86490       {
86491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86492       };
86493     } catch (std::exception& e) {
86494       {
86495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86496       };
86497     } catch (Dali::DaliException e) {
86498       {
86499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86500       };
86501     } catch (...) {
86502       {
86503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86504       };
86505     }
86506   }
86507
86508   jresult = (void *)result;
86509   return jresult;
86510 }
86511
86512
86513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86514   void * jresult ;
86515   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86516   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86517
86518   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86519   {
86520     try {
86521       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86522     } catch (std::out_of_range& e) {
86523       {
86524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86525       };
86526     } catch (std::exception& e) {
86527       {
86528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86529       };
86530     } catch (Dali::DaliException e) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86533       };
86534     } catch (...) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86537       };
86538     }
86539   }
86540
86541   jresult = (void *)result;
86542   return jresult;
86543 }
86544
86545
86546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86547   void * jresult ;
86548   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86549   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86550
86551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86552   {
86553     try {
86554       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86555     } catch (std::out_of_range& e) {
86556       {
86557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (std::exception& e) {
86560       {
86561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86562       };
86563     } catch (Dali::DaliException e) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86566       };
86567     } catch (...) {
86568       {
86569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86570       };
86571     }
86572   }
86573
86574   jresult = (void *)result;
86575   return jresult;
86576 }
86577
86578
86579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86580   void * jresult ;
86581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86582   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86583
86584   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86585   {
86586     try {
86587       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86588     } catch (std::out_of_range& e) {
86589       {
86590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86591       };
86592     } catch (std::exception& e) {
86593       {
86594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86595       };
86596     } catch (Dali::DaliException e) {
86597       {
86598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86599       };
86600     } catch (...) {
86601       {
86602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86603       };
86604     }
86605   }
86606
86607   jresult = (void *)result;
86608   return jresult;
86609 }
86610
86611
86612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86613   void * jresult ;
86614   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86615   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86616
86617   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86618   {
86619     try {
86620       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86621     } catch (std::out_of_range& e) {
86622       {
86623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86624       };
86625     } catch (std::exception& e) {
86626       {
86627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86628       };
86629     } catch (Dali::DaliException e) {
86630       {
86631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86632       };
86633     } catch (...) {
86634       {
86635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86636       };
86637     }
86638   }
86639
86640   jresult = (void *)result;
86641   return jresult;
86642 }
86643
86644
86645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86646   void * jresult ;
86647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86648   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86649
86650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86651   {
86652     try {
86653       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86654     } catch (std::out_of_range& e) {
86655       {
86656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86657       };
86658     } catch (std::exception& e) {
86659       {
86660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86661       };
86662     } catch (Dali::DaliException e) {
86663       {
86664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86665       };
86666     } catch (...) {
86667       {
86668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86669       };
86670     }
86671   }
86672
86673   jresult = (void *)result;
86674   return jresult;
86675 }
86676
86677
86678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86679   void * jresult ;
86680   Dali::Toolkit::StyleManager *result = 0 ;
86681
86682   {
86683     try {
86684       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86685     } catch (std::out_of_range& e) {
86686       {
86687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (std::exception& e) {
86690       {
86691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86692       };
86693     } catch (Dali::DaliException e) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86696       };
86697     } catch (...) {
86698       {
86699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86700       };
86701     }
86702   }
86703
86704   jresult = (void *)result;
86705   return jresult;
86706 }
86707
86708
86709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86710   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86711
86712   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86713   {
86714     try {
86715       delete arg1;
86716     } catch (std::out_of_range& e) {
86717       {
86718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86719       };
86720     } catch (std::exception& e) {
86721       {
86722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86723       };
86724     } catch (Dali::DaliException e) {
86725       {
86726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86727       };
86728     } catch (...) {
86729       {
86730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86731       };
86732     }
86733   }
86734
86735 }
86736
86737
86738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86739   void * jresult ;
86740   Dali::Toolkit::StyleManager result;
86741
86742   {
86743     try {
86744       result = Dali::Toolkit::StyleManager::Get();
86745     } catch (std::out_of_range& e) {
86746       {
86747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86748       };
86749     } catch (std::exception& e) {
86750       {
86751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86752       };
86753     } catch (Dali::DaliException e) {
86754       {
86755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86756       };
86757     } catch (...) {
86758       {
86759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86760       };
86761     }
86762   }
86763
86764   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86765   return jresult;
86766 }
86767
86768
86769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86770   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86771   std::string *arg2 = 0 ;
86772
86773   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86774   if (!jarg2) {
86775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86776     return ;
86777   }
86778   std::string arg2_str(jarg2);
86779   arg2 = &arg2_str;
86780   {
86781     try {
86782       (arg1)->ApplyTheme((std::string const &)*arg2);
86783     } catch (std::out_of_range& e) {
86784       {
86785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86786       };
86787     } catch (std::exception& e) {
86788       {
86789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86790       };
86791     } catch (Dali::DaliException e) {
86792       {
86793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86794       };
86795     } catch (...) {
86796       {
86797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86798       };
86799     }
86800   }
86801
86802
86803   //argout typemap for const std::string&
86804
86805 }
86806
86807
86808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86809   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86810
86811   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86812   {
86813     try {
86814       (arg1)->ApplyDefaultTheme();
86815     } catch (std::out_of_range& e) {
86816       {
86817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86818       };
86819     } catch (std::exception& e) {
86820       {
86821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86822       };
86823     } catch (Dali::DaliException e) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86826       };
86827     } catch (...) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86830       };
86831     }
86832   }
86833
86834 }
86835
86836
86837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86838   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86839   std::string *arg2 = 0 ;
86840   Dali::Property::Value *arg3 = 0 ;
86841
86842   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86843   if (!jarg2) {
86844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86845     return ;
86846   }
86847   std::string arg2_str(jarg2);
86848   arg2 = &arg2_str;
86849   arg3 = (Dali::Property::Value *)jarg3;
86850   if (!arg3) {
86851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86852     return ;
86853   }
86854   {
86855     try {
86856       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86857     } catch (std::out_of_range& e) {
86858       {
86859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86860       };
86861     } catch (std::exception& e) {
86862       {
86863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86864       };
86865     } catch (Dali::DaliException e) {
86866       {
86867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86868       };
86869     } catch (...) {
86870       {
86871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86872       };
86873     }
86874   }
86875
86876
86877   //argout typemap for const std::string&
86878
86879 }
86880
86881
86882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86883   unsigned int jresult ;
86884   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86885   std::string *arg2 = 0 ;
86886   Dali::Property::Value *arg3 = 0 ;
86887   bool result;
86888
86889   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86890   if (!jarg2) {
86891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86892     return 0;
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 & type is null", 0);
86899     return 0;
86900   }
86901   {
86902     try {
86903       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86904     } catch (std::out_of_range& e) {
86905       {
86906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86907       };
86908     } catch (std::exception& e) {
86909       {
86910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (Dali::DaliException e) {
86913       {
86914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86919       };
86920     }
86921   }
86922
86923   jresult = result;
86924
86925   //argout typemap for const std::string&
86926
86927   return jresult;
86928 }
86929
86930
86931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86932   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86933   Dali::Toolkit::Control arg2 ;
86934   std::string *arg3 = 0 ;
86935   std::string *arg4 = 0 ;
86936   Dali::Toolkit::Control *argp2 ;
86937
86938   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86939   argp2 = (Dali::Toolkit::Control *)jarg2;
86940   if (!argp2) {
86941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86942     return ;
86943   }
86944   arg2 = *argp2;
86945   if (!jarg3) {
86946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86947     return ;
86948   }
86949   std::string arg3_str(jarg3);
86950   arg3 = &arg3_str;
86951   if (!jarg4) {
86952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86953     return ;
86954   }
86955   std::string arg4_str(jarg4);
86956   arg4 = &arg4_str;
86957   {
86958     try {
86959       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86960     } catch (std::out_of_range& e) {
86961       {
86962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86963       };
86964     } catch (std::exception& e) {
86965       {
86966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86967       };
86968     } catch (Dali::DaliException e) {
86969       {
86970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86971       };
86972     } catch (...) {
86973       {
86974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86975       };
86976     }
86977   }
86978
86979
86980   //argout typemap for const std::string&
86981
86982
86983   //argout typemap for const std::string&
86984
86985 }
86986
86987
86988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86989   void * jresult ;
86990   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86991   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86992
86993   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86994   {
86995     try {
86996       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86997     } catch (std::out_of_range& e) {
86998       {
86999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87000       };
87001     } catch (std::exception& e) {
87002       {
87003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87004       };
87005     } catch (Dali::DaliException e) {
87006       {
87007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87008       };
87009     } catch (...) {
87010       {
87011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87012       };
87013     }
87014   }
87015
87016   jresult = (void *)result;
87017   return jresult;
87018 }
87019
87020
87021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87022   int jresult ;
87023   int result;
87024
87025   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87026   jresult = (int)result;
87027   return jresult;
87028 }
87029
87030
87031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87032   int jresult ;
87033   int result;
87034
87035   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87036   jresult = (int)result;
87037   return jresult;
87038 }
87039
87040
87041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87042   int jresult ;
87043   int result;
87044
87045   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87046   jresult = (int)result;
87047   return jresult;
87048 }
87049
87050
87051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87052   int jresult ;
87053   int result;
87054
87055   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87056   jresult = (int)result;
87057   return jresult;
87058 }
87059
87060
87061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87062   int jresult ;
87063   int result;
87064
87065   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87066   jresult = (int)result;
87067   return jresult;
87068 }
87069
87070
87071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87072   int jresult ;
87073   int result;
87074
87075   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87076   jresult = (int)result;
87077   return jresult;
87078 }
87079
87080
87081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87082   int jresult ;
87083   int result;
87084
87085   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87086   jresult = (int)result;
87087   return jresult;
87088 }
87089
87090
87091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87092   int jresult ;
87093   int result;
87094
87095   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87096   jresult = (int)result;
87097   return jresult;
87098 }
87099
87100
87101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87102   int jresult ;
87103   int result;
87104
87105   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87106   jresult = (int)result;
87107   return jresult;
87108 }
87109
87110
87111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87112   int jresult ;
87113   int result;
87114
87115   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87116   jresult = (int)result;
87117   return jresult;
87118 }
87119
87120
87121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87122   int jresult ;
87123   int result;
87124
87125   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87126   jresult = (int)result;
87127   return jresult;
87128 }
87129
87130
87131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87132   int jresult ;
87133   int result;
87134
87135   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87136   jresult = (int)result;
87137   return jresult;
87138 }
87139
87140
87141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87142   int jresult ;
87143   int result;
87144
87145   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87146   jresult = (int)result;
87147   return jresult;
87148 }
87149
87150
87151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87152   int jresult ;
87153   int result;
87154
87155   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87156   jresult = (int)result;
87157   return jresult;
87158 }
87159
87160
87161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87162   int jresult ;
87163   int result;
87164
87165   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87166   jresult = (int)result;
87167   return jresult;
87168 }
87169
87170
87171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87172   void * jresult ;
87173   Dali::Toolkit::Slider::Property *result = 0 ;
87174
87175   {
87176     try {
87177       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87178     } catch (std::out_of_range& e) {
87179       {
87180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87181       };
87182     } catch (std::exception& e) {
87183       {
87184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87185       };
87186     } catch (Dali::DaliException e) {
87187       {
87188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87189       };
87190     } catch (...) {
87191       {
87192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87193       };
87194     }
87195   }
87196
87197   jresult = (void *)result;
87198   return jresult;
87199 }
87200
87201
87202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87203   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87204
87205   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87206   {
87207     try {
87208       delete arg1;
87209     } catch (std::out_of_range& e) {
87210       {
87211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87212       };
87213     } catch (std::exception& e) {
87214       {
87215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87216       };
87217     } catch (Dali::DaliException e) {
87218       {
87219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87220       };
87221     } catch (...) {
87222       {
87223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87224       };
87225     }
87226   }
87227
87228 }
87229
87230
87231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87232   void * jresult ;
87233   Dali::Toolkit::Slider result;
87234
87235   {
87236     try {
87237       result = Dali::Toolkit::Slider::New();
87238     } catch (std::out_of_range& e) {
87239       {
87240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87241       };
87242     } catch (std::exception& e) {
87243       {
87244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87245       };
87246     } catch (Dali::DaliException e) {
87247       {
87248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87249       };
87250     } catch (...) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87253       };
87254     }
87255   }
87256
87257   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87258   return jresult;
87259 }
87260
87261
87262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87263   void * jresult ;
87264   Dali::Toolkit::Slider *result = 0 ;
87265
87266   {
87267     try {
87268       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87269     } catch (std::out_of_range& e) {
87270       {
87271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87272       };
87273     } catch (std::exception& e) {
87274       {
87275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87276       };
87277     } catch (Dali::DaliException e) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87280       };
87281     } catch (...) {
87282       {
87283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87284       };
87285     }
87286   }
87287
87288   jresult = (void *)result;
87289   return jresult;
87290 }
87291
87292
87293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87294   void * jresult ;
87295   Dali::Toolkit::Slider *arg1 = 0 ;
87296   Dali::Toolkit::Slider *result = 0 ;
87297
87298   arg1 = (Dali::Toolkit::Slider *)jarg1;
87299   if (!arg1) {
87300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87301     return 0;
87302   }
87303   {
87304     try {
87305       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87306     } catch (std::out_of_range& e) {
87307       {
87308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87309       };
87310     } catch (std::exception& e) {
87311       {
87312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87313       };
87314     } catch (Dali::DaliException e) {
87315       {
87316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87317       };
87318     } catch (...) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87321       };
87322     }
87323   }
87324
87325   jresult = (void *)result;
87326   return jresult;
87327 }
87328
87329
87330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87331   void * jresult ;
87332   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87333   Dali::Toolkit::Slider *arg2 = 0 ;
87334   Dali::Toolkit::Slider *result = 0 ;
87335
87336   arg1 = (Dali::Toolkit::Slider *)jarg1;
87337   arg2 = (Dali::Toolkit::Slider *)jarg2;
87338   if (!arg2) {
87339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87340     return 0;
87341   }
87342   {
87343     try {
87344       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87345     } catch (std::out_of_range& e) {
87346       {
87347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87348       };
87349     } catch (std::exception& e) {
87350       {
87351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87352       };
87353     } catch (Dali::DaliException e) {
87354       {
87355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87356       };
87357     } catch (...) {
87358       {
87359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87360       };
87361     }
87362   }
87363
87364   jresult = (void *)result;
87365   return jresult;
87366 }
87367
87368
87369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87370   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87371
87372   arg1 = (Dali::Toolkit::Slider *)jarg1;
87373   {
87374     try {
87375       delete arg1;
87376     } catch (std::out_of_range& e) {
87377       {
87378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87379       };
87380     } catch (std::exception& e) {
87381       {
87382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87383       };
87384     } catch (Dali::DaliException e) {
87385       {
87386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87387       };
87388     } catch (...) {
87389       {
87390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87391       };
87392     }
87393   }
87394
87395 }
87396
87397
87398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87399   void * jresult ;
87400   Dali::BaseHandle arg1 ;
87401   Dali::BaseHandle *argp1 ;
87402   Dali::Toolkit::Slider result;
87403
87404   argp1 = (Dali::BaseHandle *)jarg1;
87405   if (!argp1) {
87406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87407     return 0;
87408   }
87409   arg1 = *argp1;
87410   {
87411     try {
87412       result = Dali::Toolkit::Slider::DownCast(arg1);
87413     } catch (std::out_of_range& e) {
87414       {
87415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87416       };
87417     } catch (std::exception& e) {
87418       {
87419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87420       };
87421     } catch (Dali::DaliException e) {
87422       {
87423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87424       };
87425     } catch (...) {
87426       {
87427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87428       };
87429     }
87430   }
87431
87432   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87433   return jresult;
87434 }
87435
87436
87437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87438   void * jresult ;
87439   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87440   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87441
87442   arg1 = (Dali::Toolkit::Slider *)jarg1;
87443   {
87444     try {
87445       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87446     } catch (std::out_of_range& e) {
87447       {
87448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (std::exception& e) {
87451       {
87452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (Dali::DaliException e) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87457       };
87458     } catch (...) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87461       };
87462     }
87463   }
87464
87465   jresult = (void *)result;
87466   return jresult;
87467 }
87468
87469
87470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87471   void * jresult ;
87472   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87473   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87474
87475   arg1 = (Dali::Toolkit::Slider *)jarg1;
87476   {
87477     try {
87478       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87479     } catch (std::out_of_range& e) {
87480       {
87481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87482       };
87483     } catch (std::exception& e) {
87484       {
87485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87486       };
87487     } catch (Dali::DaliException e) {
87488       {
87489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87490       };
87491     } catch (...) {
87492       {
87493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87494       };
87495     }
87496   }
87497
87498   jresult = (void *)result;
87499   return jresult;
87500 }
87501
87502
87503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87504   void * jresult ;
87505   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87506   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87507
87508   arg1 = (Dali::Toolkit::Slider *)jarg1;
87509   {
87510     try {
87511       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87519       };
87520     } catch (Dali::DaliException e) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87527       };
87528     }
87529   }
87530
87531   jresult = (void *)result;
87532   return jresult;
87533 }
87534
87535
87536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87537   int jresult ;
87538   int result;
87539
87540   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87541   jresult = (int)result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87547   int jresult ;
87548   int result;
87549
87550   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87551   jresult = (int)result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87557   int jresult ;
87558   int result;
87559
87560   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87561   jresult = (int)result;
87562   return jresult;
87563 }
87564
87565
87566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87567   int jresult ;
87568   int result;
87569
87570   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87571   jresult = (int)result;
87572   return jresult;
87573 }
87574
87575
87576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87577   int result;
87578
87579   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87580
87581   return result;
87582 }
87583
87584
87585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87586   void * jresult ;
87587   Dali::Toolkit::VideoView::Property *result = 0 ;
87588
87589   {
87590     try {
87591       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87592     } catch (std::out_of_range& e) {
87593       {
87594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87595       };
87596     } catch (std::exception& e) {
87597       {
87598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87599       };
87600     } catch (Dali::DaliException e) {
87601       {
87602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87603       };
87604     } catch (...) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87607       };
87608     }
87609   }
87610
87611   jresult = (void *)result;
87612   return jresult;
87613 }
87614
87615
87616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87617   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87618
87619   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87620   {
87621     try {
87622       delete arg1;
87623     } catch (std::out_of_range& e) {
87624       {
87625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87626       };
87627     } catch (std::exception& e) {
87628       {
87629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87630       };
87631     } catch (Dali::DaliException e) {
87632       {
87633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87634       };
87635     } catch (...) {
87636       {
87637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87638       };
87639     }
87640   }
87641
87642 }
87643
87644
87645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87646   void * jresult ;
87647   Dali::Toolkit::VideoView result;
87648
87649   {
87650     try {
87651       result = Dali::Toolkit::VideoView::New();
87652     } catch (std::out_of_range& e) {
87653       {
87654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87655       };
87656     } catch (std::exception& e) {
87657       {
87658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87659       };
87660     } catch (Dali::DaliException e) {
87661       {
87662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87663       };
87664     } catch (...) {
87665       {
87666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87667       };
87668     }
87669   }
87670
87671   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87672   return jresult;
87673 }
87674
87675
87676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87677   void * jresult ;
87678   std::string *arg1 = 0 ;
87679   Dali::Toolkit::VideoView result;
87680
87681   if (!jarg1) {
87682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87683     return 0;
87684   }
87685   std::string arg1_str(jarg1);
87686   arg1 = &arg1_str;
87687   {
87688     try {
87689       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87690     } catch (std::out_of_range& e) {
87691       {
87692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87693       };
87694     } catch (std::exception& e) {
87695       {
87696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87697       };
87698     } catch (Dali::DaliException e) {
87699       {
87700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87701       };
87702     } catch (...) {
87703       {
87704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87705       };
87706     }
87707   }
87708
87709   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87710
87711   //argout typemap for const std::string&
87712
87713   return jresult;
87714 }
87715
87716
87717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87718   void * jresult ;
87719   Dali::Toolkit::VideoView *result = 0 ;
87720
87721   {
87722     try {
87723       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87724     } catch (std::out_of_range& e) {
87725       {
87726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87727       };
87728     } catch (std::exception& e) {
87729       {
87730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87731       };
87732     } catch (Dali::DaliException e) {
87733       {
87734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87739       };
87740     }
87741   }
87742
87743   jresult = (void *)result;
87744   return jresult;
87745 }
87746
87747
87748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87749   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87750
87751   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87752   {
87753     try {
87754       delete arg1;
87755     } catch (std::out_of_range& e) {
87756       {
87757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87758       };
87759     } catch (std::exception& e) {
87760       {
87761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87762       };
87763     } catch (Dali::DaliException e) {
87764       {
87765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87766       };
87767     } catch (...) {
87768       {
87769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87770       };
87771     }
87772   }
87773
87774 }
87775
87776
87777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87778   void * jresult ;
87779   Dali::Toolkit::VideoView *arg1 = 0 ;
87780   Dali::Toolkit::VideoView *result = 0 ;
87781
87782   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87783   if (!arg1) {
87784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87785     return 0;
87786   }
87787   {
87788     try {
87789       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87790     } catch (std::out_of_range& e) {
87791       {
87792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87793       };
87794     } catch (std::exception& e) {
87795       {
87796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87797       };
87798     } catch (Dali::DaliException e) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87801       };
87802     } catch (...) {
87803       {
87804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87805       };
87806     }
87807   }
87808
87809   jresult = (void *)result;
87810   return jresult;
87811 }
87812
87813
87814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87815   void * jresult ;
87816   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87817   Dali::Toolkit::VideoView *arg2 = 0 ;
87818   Dali::Toolkit::VideoView *result = 0 ;
87819
87820   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87821   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87822   if (!arg2) {
87823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87824     return 0;
87825   }
87826   {
87827     try {
87828       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87829     } catch (std::out_of_range& e) {
87830       {
87831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87832       };
87833     } catch (std::exception& e) {
87834       {
87835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87836       };
87837     } catch (Dali::DaliException e) {
87838       {
87839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87840       };
87841     } catch (...) {
87842       {
87843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87844       };
87845     }
87846   }
87847
87848   jresult = (void *)result;
87849   return jresult;
87850 }
87851
87852
87853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87854   void * jresult ;
87855   Dali::BaseHandle arg1 ;
87856   Dali::BaseHandle *argp1 ;
87857   Dali::Toolkit::VideoView result;
87858
87859   argp1 = (Dali::BaseHandle *)jarg1;
87860   if (!argp1) {
87861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87862     return 0;
87863   }
87864   arg1 = *argp1;
87865   {
87866     try {
87867       result = Dali::Toolkit::VideoView::DownCast(arg1);
87868     } catch (std::out_of_range& e) {
87869       {
87870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87871       };
87872     } catch (std::exception& e) {
87873       {
87874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87875       };
87876     } catch (Dali::DaliException e) {
87877       {
87878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87879       };
87880     } catch (...) {
87881       {
87882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87883       };
87884     }
87885   }
87886
87887   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87888   return jresult;
87889 }
87890
87891
87892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87893   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87894
87895   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87896   {
87897     try {
87898       (arg1)->Play();
87899     } catch (std::out_of_range& e) {
87900       {
87901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87902       };
87903     } catch (std::exception& e) {
87904       {
87905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87906       };
87907     } catch (Dali::DaliException e) {
87908       {
87909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87910       };
87911     } catch (...) {
87912       {
87913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87914       };
87915     }
87916   }
87917
87918 }
87919
87920
87921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87922   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87923
87924   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87925   {
87926     try {
87927       (arg1)->Pause();
87928     } catch (std::out_of_range& e) {
87929       {
87930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87931       };
87932     } catch (std::exception& e) {
87933       {
87934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87935       };
87936     } catch (Dali::DaliException e) {
87937       {
87938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87939       };
87940     } catch (...) {
87941       {
87942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87943       };
87944     }
87945   }
87946
87947 }
87948
87949
87950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87951   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87952
87953   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87954   {
87955     try {
87956       (arg1)->Stop();
87957     } catch (std::out_of_range& e) {
87958       {
87959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87960       };
87961     } catch (std::exception& e) {
87962       {
87963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87964       };
87965     } catch (Dali::DaliException e) {
87966       {
87967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87968       };
87969     } catch (...) {
87970       {
87971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87972       };
87973     }
87974   }
87975
87976 }
87977
87978
87979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87980   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87981   int arg2 ;
87982
87983   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87984   arg2 = (int)jarg2;
87985   {
87986     try {
87987       (arg1)->Forward(arg2);
87988     } catch (std::out_of_range& e) {
87989       {
87990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87991       };
87992     } catch (std::exception& e) {
87993       {
87994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87995       };
87996     } catch (Dali::DaliException e) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87999       };
88000     } catch (...) {
88001       {
88002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88003       };
88004     }
88005   }
88006
88007 }
88008
88009
88010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88011   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88012   int arg2 ;
88013
88014   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88015   arg2 = (int)jarg2;
88016   {
88017     try {
88018       (arg1)->Backward(arg2);
88019     } catch (std::out_of_range& e) {
88020       {
88021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88022       };
88023     } catch (std::exception& e) {
88024       {
88025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88026       };
88027     } catch (Dali::DaliException e) {
88028       {
88029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88030       };
88031     } catch (...) {
88032       {
88033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88034       };
88035     }
88036   }
88037
88038 }
88039
88040
88041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88042   void * jresult ;
88043   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88044   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88045
88046   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88047   {
88048     try {
88049       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88050     } catch (std::out_of_range& e) {
88051       {
88052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88053       };
88054     } catch (std::exception& e) {
88055       {
88056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88057       };
88058     } catch (Dali::DaliException e) {
88059       {
88060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88061       };
88062     } catch (...) {
88063       {
88064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88065       };
88066     }
88067   }
88068
88069   jresult = (void *)result;
88070   return jresult;
88071 }
88072
88073
88074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88075   int jresult ;
88076   int result;
88077
88078   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88079   jresult = (int)result;
88080   return jresult;
88081 }
88082
88083
88084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88085   int jresult ;
88086   int result;
88087
88088   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88089   jresult = (int)result;
88090   return jresult;
88091 }
88092
88093
88094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88095   int jresult ;
88096   int result;
88097
88098   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88099   jresult = (int)result;
88100   return jresult;
88101 }
88102
88103
88104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88105   int jresult ;
88106   int result;
88107
88108   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88109   jresult = (int)result;
88110   return jresult;
88111 }
88112
88113
88114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88115   int jresult ;
88116   int result;
88117
88118   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88119   jresult = (int)result;
88120   return jresult;
88121 }
88122
88123
88124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88125   int jresult ;
88126   int result;
88127
88128   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88129   jresult = (int)result;
88130   return jresult;
88131 }
88132
88133
88134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88135   int jresult ;
88136   int result;
88137
88138   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88139   jresult = (int)result;
88140   return jresult;
88141 }
88142
88143
88144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88145   int jresult ;
88146   int result;
88147
88148   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88149   jresult = (int)result;
88150   return jresult;
88151 }
88152
88153
88154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88155   int jresult ;
88156   int result;
88157
88158   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88159   jresult = (int)result;
88160   return jresult;
88161 }
88162
88163
88164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88165   int jresult ;
88166   int result;
88167
88168   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88169   jresult = (int)result;
88170   return jresult;
88171 }
88172
88173
88174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88175   int jresult ;
88176   int result;
88177
88178   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88179   jresult = (int)result;
88180   return jresult;
88181 }
88182
88183
88184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88185   int jresult ;
88186   int result;
88187
88188   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88189   jresult = (int)result;
88190   return jresult;
88191 }
88192
88193
88194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88195   int jresult ;
88196   int result;
88197
88198   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88199   jresult = (int)result;
88200   return jresult;
88201 }
88202
88203
88204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88205   int jresult ;
88206   int result;
88207
88208   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88209   jresult = (int)result;
88210   return jresult;
88211 }
88212
88213
88214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88215   int jresult ;
88216   int result;
88217
88218   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88219   jresult = (int)result;
88220   return jresult;
88221 }
88222
88223
88224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88225   int jresult ;
88226   int result;
88227
88228   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88229   jresult = (int)result;
88230   return jresult;
88231 }
88232
88233
88234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88235   int jresult ;
88236   int result;
88237
88238   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88239   jresult = (int)result;
88240   return jresult;
88241 }
88242
88243
88244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88245   int jresult ;
88246   int result;
88247
88248   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88249   jresult = (int)result;
88250   return jresult;
88251 }
88252
88253
88254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88255   int jresult ;
88256   int result;
88257
88258   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88259   jresult = (int)result;
88260   return jresult;
88261 }
88262
88263
88264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88265   int jresult ;
88266   int result;
88267
88268   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88269   jresult = (int)result;
88270   return jresult;
88271 }
88272
88273
88274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88275   int jresult ;
88276   int result;
88277
88278   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88279   jresult = (int)result;
88280   return jresult;
88281 }
88282
88283
88284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88285   void * jresult ;
88286   Dali::Toolkit::Popup::Property *result = 0 ;
88287
88288   {
88289     try {
88290       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88291     } catch (std::out_of_range& e) {
88292       {
88293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88294       };
88295     } catch (std::exception& e) {
88296       {
88297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88298       };
88299     } catch (Dali::DaliException e) {
88300       {
88301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88302       };
88303     } catch (...) {
88304       {
88305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88306       };
88307     }
88308   }
88309
88310   jresult = (void *)result;
88311   return jresult;
88312 }
88313
88314
88315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88316   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88317
88318   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88319   {
88320     try {
88321       delete arg1;
88322     } catch (std::out_of_range& e) {
88323       {
88324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88325       };
88326     } catch (std::exception& e) {
88327       {
88328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88329       };
88330     } catch (Dali::DaliException e) {
88331       {
88332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88333       };
88334     } catch (...) {
88335       {
88336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88337       };
88338     }
88339   }
88340
88341 }
88342
88343
88344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88345   void * jresult ;
88346   Dali::Toolkit::Popup *result = 0 ;
88347
88348   {
88349     try {
88350       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88351     } catch (std::out_of_range& e) {
88352       {
88353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88354       };
88355     } catch (std::exception& e) {
88356       {
88357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88358       };
88359     } catch (Dali::DaliException e) {
88360       {
88361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88362       };
88363     } catch (...) {
88364       {
88365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88366       };
88367     }
88368   }
88369
88370   jresult = (void *)result;
88371   return jresult;
88372 }
88373
88374
88375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88376   void * jresult ;
88377   Dali::Toolkit::Popup result;
88378
88379   {
88380     try {
88381       result = Dali::Toolkit::Popup::New();
88382     } catch (std::out_of_range& e) {
88383       {
88384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88385       };
88386     } catch (std::exception& e) {
88387       {
88388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88389       };
88390     } catch (Dali::DaliException e) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88393       };
88394     } catch (...) {
88395       {
88396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88397       };
88398     }
88399   }
88400
88401   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88402   return jresult;
88403 }
88404
88405
88406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88407   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88408
88409   arg1 = (Dali::Toolkit::Popup *)jarg1;
88410   {
88411     try {
88412       delete arg1;
88413     } catch (std::out_of_range& e) {
88414       {
88415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88416       };
88417     } catch (std::exception& e) {
88418       {
88419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88420       };
88421     } catch (Dali::DaliException e) {
88422       {
88423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88424       };
88425     } catch (...) {
88426       {
88427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88428       };
88429     }
88430   }
88431
88432 }
88433
88434
88435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88436   void * jresult ;
88437   Dali::Toolkit::Popup *arg1 = 0 ;
88438   Dali::Toolkit::Popup *result = 0 ;
88439
88440   arg1 = (Dali::Toolkit::Popup *)jarg1;
88441   if (!arg1) {
88442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88443     return 0;
88444   }
88445   {
88446     try {
88447       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88448     } catch (std::out_of_range& e) {
88449       {
88450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88451       };
88452     } catch (std::exception& e) {
88453       {
88454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88455       };
88456     } catch (Dali::DaliException e) {
88457       {
88458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88459       };
88460     } catch (...) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88463       };
88464     }
88465   }
88466
88467   jresult = (void *)result;
88468   return jresult;
88469 }
88470
88471
88472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88473   void * jresult ;
88474   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88475   Dali::Toolkit::Popup *arg2 = 0 ;
88476   Dali::Toolkit::Popup *result = 0 ;
88477
88478   arg1 = (Dali::Toolkit::Popup *)jarg1;
88479   arg2 = (Dali::Toolkit::Popup *)jarg2;
88480   if (!arg2) {
88481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88482     return 0;
88483   }
88484   {
88485     try {
88486       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88487     } catch (std::out_of_range& e) {
88488       {
88489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88490       };
88491     } catch (std::exception& e) {
88492       {
88493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (Dali::DaliException e) {
88496       {
88497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88498       };
88499     } catch (...) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88502       };
88503     }
88504   }
88505
88506   jresult = (void *)result;
88507   return jresult;
88508 }
88509
88510
88511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88512   void * jresult ;
88513   Dali::BaseHandle arg1 ;
88514   Dali::BaseHandle *argp1 ;
88515   Dali::Toolkit::Popup result;
88516
88517   argp1 = (Dali::BaseHandle *)jarg1;
88518   if (!argp1) {
88519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88520     return 0;
88521   }
88522   arg1 = *argp1;
88523   {
88524     try {
88525       result = Dali::Toolkit::Popup::DownCast(arg1);
88526     } catch (std::out_of_range& e) {
88527       {
88528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88529       };
88530     } catch (std::exception& e) {
88531       {
88532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88533       };
88534     } catch (Dali::DaliException e) {
88535       {
88536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88537       };
88538     } catch (...) {
88539       {
88540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88541       };
88542     }
88543   }
88544
88545   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88546   return jresult;
88547 }
88548
88549
88550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88551   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88552   Dali::Actor arg2 ;
88553   Dali::Actor *argp2 ;
88554
88555   arg1 = (Dali::Toolkit::Popup *)jarg1;
88556   argp2 = (Dali::Actor *)jarg2;
88557   if (!argp2) {
88558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88559     return ;
88560   }
88561   arg2 = *argp2;
88562   {
88563     try {
88564       (arg1)->SetTitle(arg2);
88565     } catch (std::out_of_range& e) {
88566       {
88567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88568       };
88569     } catch (std::exception& e) {
88570       {
88571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88572       };
88573     } catch (Dali::DaliException e) {
88574       {
88575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88576       };
88577     } catch (...) {
88578       {
88579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88580       };
88581     }
88582   }
88583
88584 }
88585
88586
88587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88588   void * jresult ;
88589   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88590   Dali::Actor result;
88591
88592   arg1 = (Dali::Toolkit::Popup *)jarg1;
88593   {
88594     try {
88595       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88596     } catch (std::out_of_range& e) {
88597       {
88598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88599       };
88600     } catch (std::exception& e) {
88601       {
88602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88603       };
88604     } catch (Dali::DaliException e) {
88605       {
88606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88607       };
88608     } catch (...) {
88609       {
88610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88611       };
88612     }
88613   }
88614
88615   jresult = new Dali::Actor((const Dali::Actor &)result);
88616   return jresult;
88617 }
88618
88619
88620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88621   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88622   Dali::Actor arg2 ;
88623   Dali::Actor *argp2 ;
88624
88625   arg1 = (Dali::Toolkit::Popup *)jarg1;
88626   argp2 = (Dali::Actor *)jarg2;
88627   if (!argp2) {
88628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88629     return ;
88630   }
88631   arg2 = *argp2;
88632   {
88633     try {
88634       (arg1)->SetContent(arg2);
88635     } catch (std::out_of_range& e) {
88636       {
88637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88638       };
88639     } catch (std::exception& e) {
88640       {
88641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88642       };
88643     } catch (Dali::DaliException e) {
88644       {
88645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88646       };
88647     } catch (...) {
88648       {
88649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88650       };
88651     }
88652   }
88653
88654 }
88655
88656
88657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88658   void * jresult ;
88659   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88660   Dali::Actor result;
88661
88662   arg1 = (Dali::Toolkit::Popup *)jarg1;
88663   {
88664     try {
88665       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88666     } catch (std::out_of_range& e) {
88667       {
88668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88669       };
88670     } catch (std::exception& e) {
88671       {
88672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88673       };
88674     } catch (Dali::DaliException e) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88677       };
88678     } catch (...) {
88679       {
88680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88681       };
88682     }
88683   }
88684
88685   jresult = new Dali::Actor((const Dali::Actor &)result);
88686   return jresult;
88687 }
88688
88689
88690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88691   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88692   Dali::Actor arg2 ;
88693   Dali::Actor *argp2 ;
88694
88695   arg1 = (Dali::Toolkit::Popup *)jarg1;
88696   argp2 = (Dali::Actor *)jarg2;
88697   if (!argp2) {
88698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88699     return ;
88700   }
88701   arg2 = *argp2;
88702   {
88703     try {
88704       (arg1)->SetFooter(arg2);
88705     } catch (std::out_of_range& e) {
88706       {
88707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88708       };
88709     } catch (std::exception& e) {
88710       {
88711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88712       };
88713     } catch (Dali::DaliException e) {
88714       {
88715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88716       };
88717     } catch (...) {
88718       {
88719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88720       };
88721     }
88722   }
88723
88724 }
88725
88726
88727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88728   void * jresult ;
88729   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88730   Dali::Actor result;
88731
88732   arg1 = (Dali::Toolkit::Popup *)jarg1;
88733   {
88734     try {
88735       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88736     } catch (std::out_of_range& e) {
88737       {
88738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (std::exception& e) {
88741       {
88742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88743       };
88744     } catch (Dali::DaliException e) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88751       };
88752     }
88753   }
88754
88755   jresult = new Dali::Actor((const Dali::Actor &)result);
88756   return jresult;
88757 }
88758
88759
88760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88761   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88762   Dali::Toolkit::Popup::DisplayState arg2 ;
88763
88764   arg1 = (Dali::Toolkit::Popup *)jarg1;
88765   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88766   {
88767     try {
88768       (arg1)->SetDisplayState(arg2);
88769     } catch (std::out_of_range& e) {
88770       {
88771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88772       };
88773     } catch (std::exception& e) {
88774       {
88775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88776       };
88777     } catch (Dali::DaliException e) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88780       };
88781     } catch (...) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88784       };
88785     }
88786   }
88787
88788 }
88789
88790
88791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88792   int jresult ;
88793   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88794   Dali::Toolkit::Popup::DisplayState result;
88795
88796   arg1 = (Dali::Toolkit::Popup *)jarg1;
88797   {
88798     try {
88799       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88800     } catch (std::out_of_range& e) {
88801       {
88802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88803       };
88804     } catch (std::exception& e) {
88805       {
88806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88807       };
88808     } catch (Dali::DaliException e) {
88809       {
88810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88811       };
88812     } catch (...) {
88813       {
88814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88815       };
88816     }
88817   }
88818
88819   jresult = (int)result;
88820   return jresult;
88821 }
88822
88823
88824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88825   void * jresult ;
88826   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88827   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88828
88829   arg1 = (Dali::Toolkit::Popup *)jarg1;
88830   {
88831     try {
88832       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88833     } catch (std::out_of_range& e) {
88834       {
88835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88836       };
88837     } catch (std::exception& e) {
88838       {
88839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88840       };
88841     } catch (Dali::DaliException e) {
88842       {
88843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88844       };
88845     } catch (...) {
88846       {
88847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88848       };
88849     }
88850   }
88851
88852   jresult = (void *)result;
88853   return jresult;
88854 }
88855
88856
88857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88858   void * jresult ;
88859   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88860   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88861
88862   arg1 = (Dali::Toolkit::Popup *)jarg1;
88863   {
88864     try {
88865       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88866     } catch (std::out_of_range& e) {
88867       {
88868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (std::exception& e) {
88871       {
88872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88873       };
88874     } catch (Dali::DaliException e) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88877       };
88878     } catch (...) {
88879       {
88880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88881       };
88882     }
88883   }
88884
88885   jresult = (void *)result;
88886   return jresult;
88887 }
88888
88889
88890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88891   void * jresult ;
88892   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88893   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88894
88895   arg1 = (Dali::Toolkit::Popup *)jarg1;
88896   {
88897     try {
88898       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88899     } catch (std::out_of_range& e) {
88900       {
88901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88902       };
88903     } catch (std::exception& e) {
88904       {
88905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (Dali::DaliException e) {
88908       {
88909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88910       };
88911     } catch (...) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88914       };
88915     }
88916   }
88917
88918   jresult = (void *)result;
88919   return jresult;
88920 }
88921
88922
88923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88924   void * jresult ;
88925   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88926   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88927
88928   arg1 = (Dali::Toolkit::Popup *)jarg1;
88929   {
88930     try {
88931       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88932     } catch (std::out_of_range& e) {
88933       {
88934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88935       };
88936     } catch (std::exception& e) {
88937       {
88938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88939       };
88940     } catch (Dali::DaliException e) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88943       };
88944     } catch (...) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88947       };
88948     }
88949   }
88950
88951   jresult = (void *)result;
88952   return jresult;
88953 }
88954
88955
88956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88957   void * jresult ;
88958   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88959   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88960
88961   arg1 = (Dali::Toolkit::Popup *)jarg1;
88962   {
88963     try {
88964       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88965     } catch (std::out_of_range& e) {
88966       {
88967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88968       };
88969     } catch (std::exception& e) {
88970       {
88971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (Dali::DaliException e) {
88974       {
88975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88976       };
88977     } catch (...) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88980       };
88981     }
88982   }
88983
88984   jresult = (void *)result;
88985   return jresult;
88986 }
88987
88988
88989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88990   int jresult ;
88991   int result;
88992
88993   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88994   jresult = (int)result;
88995   return jresult;
88996 }
88997
88998
88999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89000   int jresult ;
89001   int result;
89002
89003   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89004   jresult = (int)result;
89005   return jresult;
89006 }
89007
89008
89009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89010   int jresult ;
89011   int result;
89012
89013   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89014   jresult = (int)result;
89015   return jresult;
89016 }
89017
89018
89019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89020   int jresult ;
89021   int result;
89022
89023   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89024   jresult = (int)result;
89025   return jresult;
89026 }
89027
89028
89029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89030   int jresult ;
89031   int result;
89032
89033   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89034   jresult = (int)result;
89035   return jresult;
89036 }
89037
89038
89039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89040   int jresult ;
89041   int result;
89042
89043   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89044   jresult = (int)result;
89045   return jresult;
89046 }
89047
89048
89049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89050   int jresult ;
89051   int result;
89052
89053   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89054   jresult = (int)result;
89055   return jresult;
89056 }
89057
89058
89059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89060   int jresult ;
89061   int result;
89062
89063   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89064   jresult = (int)result;
89065   return jresult;
89066 }
89067
89068
89069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89070   int jresult ;
89071   int result;
89072
89073   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89074   jresult = (int)result;
89075   return jresult;
89076 }
89077
89078
89079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89080   void * jresult ;
89081   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89082
89083   {
89084     try {
89085       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89086     } catch (std::out_of_range& e) {
89087       {
89088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89089       };
89090     } catch (std::exception& e) {
89091       {
89092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89093       };
89094     } catch (Dali::DaliException e) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89097       };
89098     } catch (...) {
89099       {
89100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89101       };
89102     }
89103   }
89104
89105   jresult = (void *)result;
89106   return jresult;
89107 }
89108
89109
89110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89111   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89112
89113   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89114   {
89115     try {
89116       delete arg1;
89117     } catch (std::out_of_range& e) {
89118       {
89119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89120       };
89121     } catch (std::exception& e) {
89122       {
89123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89124       };
89125     } catch (Dali::DaliException e) {
89126       {
89127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89128       };
89129     } catch (...) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89132       };
89133     }
89134   }
89135
89136 }
89137
89138
89139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89140   void * jresult ;
89141   Dali::Toolkit::ProgressBar result;
89142
89143   {
89144     try {
89145       result = Dali::Toolkit::ProgressBar::New();
89146     } catch (std::out_of_range& e) {
89147       {
89148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89149       };
89150     } catch (std::exception& e) {
89151       {
89152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89153       };
89154     } catch (Dali::DaliException e) {
89155       {
89156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89157       };
89158     } catch (...) {
89159       {
89160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89161       };
89162     }
89163   }
89164
89165   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89166   return jresult;
89167 }
89168
89169
89170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89171   void * jresult ;
89172   Dali::Toolkit::ProgressBar *result = 0 ;
89173
89174   {
89175     try {
89176       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89177     } catch (std::out_of_range& e) {
89178       {
89179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89180       };
89181     } catch (std::exception& e) {
89182       {
89183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89184       };
89185     } catch (Dali::DaliException e) {
89186       {
89187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89188       };
89189     } catch (...) {
89190       {
89191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89192       };
89193     }
89194   }
89195
89196   jresult = (void *)result;
89197   return jresult;
89198 }
89199
89200
89201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89202   void * jresult ;
89203   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89204   Dali::Toolkit::ProgressBar *result = 0 ;
89205
89206   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89207   if (!arg1) {
89208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89209     return 0;
89210   }
89211   {
89212     try {
89213       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89214     } catch (std::out_of_range& e) {
89215       {
89216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89217       };
89218     } catch (std::exception& e) {
89219       {
89220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89221       };
89222     } catch (Dali::DaliException e) {
89223       {
89224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89225       };
89226     } catch (...) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89229       };
89230     }
89231   }
89232
89233   jresult = (void *)result;
89234   return jresult;
89235 }
89236
89237
89238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89239   void * jresult ;
89240   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89241   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89242   Dali::Toolkit::ProgressBar *result = 0 ;
89243
89244   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89245   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89246   if (!arg2) {
89247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89248     return 0;
89249   }
89250   {
89251     try {
89252       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89253     } catch (std::out_of_range& e) {
89254       {
89255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89256       };
89257     } catch (std::exception& e) {
89258       {
89259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89260       };
89261     } catch (Dali::DaliException e) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89264       };
89265     } catch (...) {
89266       {
89267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89268       };
89269     }
89270   }
89271
89272   jresult = (void *)result;
89273   return jresult;
89274 }
89275
89276
89277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89278   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89279
89280   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89281   {
89282     try {
89283       delete arg1;
89284     } catch (std::out_of_range& e) {
89285       {
89286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89287       };
89288     } catch (std::exception& e) {
89289       {
89290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89291       };
89292     } catch (Dali::DaliException e) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89295       };
89296     } catch (...) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89299       };
89300     }
89301   }
89302
89303 }
89304
89305
89306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89307   void * jresult ;
89308   Dali::BaseHandle arg1 ;
89309   Dali::BaseHandle *argp1 ;
89310   Dali::Toolkit::ProgressBar result;
89311
89312   argp1 = (Dali::BaseHandle *)jarg1;
89313   if (!argp1) {
89314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89315     return 0;
89316   }
89317   arg1 = *argp1;
89318   {
89319     try {
89320       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89321     } catch (std::out_of_range& e) {
89322       {
89323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89324       };
89325     } catch (std::exception& e) {
89326       {
89327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89328       };
89329     } catch (Dali::DaliException e) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89332       };
89333     } catch (...) {
89334       {
89335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89336       };
89337     }
89338   }
89339
89340   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89341   return jresult;
89342 }
89343
89344
89345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89346   void * jresult ;
89347   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89348   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89349
89350   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89351   {
89352     try {
89353       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89354     } catch (std::out_of_range& e) {
89355       {
89356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (std::exception& e) {
89359       {
89360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89361       };
89362     } catch (Dali::DaliException e) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89365       };
89366     } catch (...) {
89367       {
89368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89369       };
89370     }
89371   }
89372
89373   jresult = (void *)result;
89374   return jresult;
89375 }
89376
89377
89378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89379   void * jresult ;
89380   Dali::Toolkit::GaussianBlurView *result = 0 ;
89381
89382   {
89383     try {
89384       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89385     } catch (std::out_of_range& e) {
89386       {
89387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89388       };
89389     } catch (std::exception& e) {
89390       {
89391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (Dali::DaliException e) {
89394       {
89395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89396       };
89397     } catch (...) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89400       };
89401     }
89402   }
89403
89404   jresult = (void *)result;
89405   return jresult;
89406 }
89407
89408
89409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89410   void * jresult ;
89411   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89412   Dali::Toolkit::GaussianBlurView *result = 0 ;
89413
89414   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89415   if (!arg1) {
89416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89417     return 0;
89418   }
89419   {
89420     try {
89421       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89422     } catch (std::out_of_range& e) {
89423       {
89424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89425       };
89426     } catch (std::exception& e) {
89427       {
89428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89429       };
89430     } catch (Dali::DaliException e) {
89431       {
89432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89433       };
89434     } catch (...) {
89435       {
89436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89437       };
89438     }
89439   }
89440
89441   jresult = (void *)result;
89442   return jresult;
89443 }
89444
89445
89446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89447   void * jresult ;
89448   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89449   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89450   Dali::Toolkit::GaussianBlurView *result = 0 ;
89451
89452   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89453   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89454   if (!arg2) {
89455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89456     return 0;
89457   }
89458   {
89459     try {
89460       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89461     } catch (std::out_of_range& e) {
89462       {
89463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89464       };
89465     } catch (std::exception& e) {
89466       {
89467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89468       };
89469     } catch (Dali::DaliException e) {
89470       {
89471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89472       };
89473     } catch (...) {
89474       {
89475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89476       };
89477     }
89478   }
89479
89480   jresult = (void *)result;
89481   return jresult;
89482 }
89483
89484
89485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89486   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89487
89488   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89489   {
89490     try {
89491       delete arg1;
89492     } catch (std::out_of_range& e) {
89493       {
89494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89495       };
89496     } catch (std::exception& e) {
89497       {
89498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89499       };
89500     } catch (Dali::DaliException e) {
89501       {
89502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89503       };
89504     } catch (...) {
89505       {
89506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89507       };
89508     }
89509   }
89510
89511 }
89512
89513
89514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89515   void * jresult ;
89516   Dali::BaseHandle arg1 ;
89517   Dali::BaseHandle *argp1 ;
89518   Dali::Toolkit::GaussianBlurView result;
89519
89520   argp1 = (Dali::BaseHandle *)jarg1;
89521   if (!argp1) {
89522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89523     return 0;
89524   }
89525   arg1 = *argp1;
89526   {
89527     try {
89528       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89529     } catch (std::out_of_range& e) {
89530       {
89531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89532       };
89533     } catch (std::exception& e) {
89534       {
89535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89536       };
89537     } catch (Dali::DaliException e) {
89538       {
89539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89540       };
89541     } catch (...) {
89542       {
89543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89544       };
89545     }
89546   }
89547
89548   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89549   return jresult;
89550 }
89551
89552
89553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89554   void * jresult ;
89555   Dali::Toolkit::GaussianBlurView result;
89556
89557   {
89558     try {
89559       result = Dali::Toolkit::GaussianBlurView::New();
89560     } catch (std::out_of_range& e) {
89561       {
89562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89563       };
89564     } catch (std::exception& e) {
89565       {
89566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89567       };
89568     } catch (Dali::DaliException e) {
89569       {
89570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89571       };
89572     } catch (...) {
89573       {
89574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89575       };
89576     }
89577   }
89578
89579   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89580   return jresult;
89581 }
89582
89583
89584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89585   void * jresult ;
89586   unsigned int arg1 ;
89587   float arg2 ;
89588   Dali::Pixel::Format arg3 ;
89589   float arg4 ;
89590   float arg5 ;
89591   bool arg6 ;
89592   Dali::Toolkit::GaussianBlurView result;
89593
89594   arg1 = (unsigned int)jarg1;
89595   arg2 = (float)jarg2;
89596   arg3 = (Dali::Pixel::Format)jarg3;
89597   arg4 = (float)jarg4;
89598   arg5 = (float)jarg5;
89599   arg6 = jarg6 ? true : false;
89600   {
89601     try {
89602       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89603     } catch (std::out_of_range& e) {
89604       {
89605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89606       };
89607     } catch (std::exception& e) {
89608       {
89609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89610       };
89611     } catch (Dali::DaliException e) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89614       };
89615     } catch (...) {
89616       {
89617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89618       };
89619     }
89620   }
89621
89622   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89623   return jresult;
89624 }
89625
89626
89627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89628   void * jresult ;
89629   unsigned int arg1 ;
89630   float arg2 ;
89631   Dali::Pixel::Format arg3 ;
89632   float arg4 ;
89633   float arg5 ;
89634   Dali::Toolkit::GaussianBlurView result;
89635
89636   arg1 = (unsigned int)jarg1;
89637   arg2 = (float)jarg2;
89638   arg3 = (Dali::Pixel::Format)jarg3;
89639   arg4 = (float)jarg4;
89640   arg5 = (float)jarg5;
89641   {
89642     try {
89643       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89644     } catch (std::out_of_range& e) {
89645       {
89646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89647       };
89648     } catch (std::exception& e) {
89649       {
89650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89651       };
89652     } catch (Dali::DaliException e) {
89653       {
89654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89655       };
89656     } catch (...) {
89657       {
89658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89659       };
89660     }
89661   }
89662
89663   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89664   return jresult;
89665 }
89666
89667
89668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89669   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89670   Dali::Actor arg2 ;
89671   Dali::Actor *argp2 ;
89672
89673   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89674   argp2 = (Dali::Actor *)jarg2;
89675   if (!argp2) {
89676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89677     return ;
89678   }
89679   arg2 = *argp2;
89680   {
89681     try {
89682       (arg1)->Add(arg2);
89683     } catch (std::out_of_range& e) {
89684       {
89685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89686       };
89687     } catch (std::exception& e) {
89688       {
89689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89690       };
89691     } catch (Dali::DaliException e) {
89692       {
89693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89694       };
89695     } catch (...) {
89696       {
89697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89698       };
89699     }
89700   }
89701
89702 }
89703
89704
89705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89706   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89707   Dali::Actor arg2 ;
89708   Dali::Actor *argp2 ;
89709
89710   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89711   argp2 = (Dali::Actor *)jarg2;
89712   if (!argp2) {
89713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89714     return ;
89715   }
89716   arg2 = *argp2;
89717   {
89718     try {
89719       (arg1)->Remove(arg2);
89720     } catch (std::out_of_range& e) {
89721       {
89722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89723       };
89724     } catch (std::exception& e) {
89725       {
89726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89727       };
89728     } catch (Dali::DaliException e) {
89729       {
89730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89731       };
89732     } catch (...) {
89733       {
89734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89735       };
89736     }
89737   }
89738
89739 }
89740
89741
89742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89743   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89744
89745   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89746   {
89747     try {
89748       (arg1)->Activate();
89749     } catch (std::out_of_range& e) {
89750       {
89751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89752       };
89753     } catch (std::exception& e) {
89754       {
89755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89756       };
89757     } catch (Dali::DaliException e) {
89758       {
89759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89760       };
89761     } catch (...) {
89762       {
89763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89764       };
89765     }
89766   }
89767
89768 }
89769
89770
89771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89772   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89773
89774   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89775   {
89776     try {
89777       (arg1)->ActivateOnce();
89778     } catch (std::out_of_range& e) {
89779       {
89780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89781       };
89782     } catch (std::exception& e) {
89783       {
89784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89785       };
89786     } catch (Dali::DaliException e) {
89787       {
89788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89789       };
89790     } catch (...) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89793       };
89794     }
89795   }
89796
89797 }
89798
89799
89800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89801   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89802
89803   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89804   {
89805     try {
89806       (arg1)->Deactivate();
89807     } catch (std::out_of_range& e) {
89808       {
89809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89810       };
89811     } catch (std::exception& e) {
89812       {
89813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89814       };
89815     } catch (Dali::DaliException e) {
89816       {
89817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89818       };
89819     } catch (...) {
89820       {
89821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89822       };
89823     }
89824   }
89825
89826 }
89827
89828
89829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89830   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89831   Dali::Image arg2 ;
89832   Dali::FrameBufferImage arg3 ;
89833   Dali::Image *argp2 ;
89834   Dali::FrameBufferImage *argp3 ;
89835
89836   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89837   argp2 = (Dali::Image *)jarg2;
89838   if (!argp2) {
89839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89840     return ;
89841   }
89842   arg2 = *argp2;
89843   argp3 = (Dali::FrameBufferImage *)jarg3;
89844   if (!argp3) {
89845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89846     return ;
89847   }
89848   arg3 = *argp3;
89849   {
89850     try {
89851       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89852     } catch (std::out_of_range& e) {
89853       {
89854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89855       };
89856     } catch (std::exception& e) {
89857       {
89858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89859       };
89860     } catch (Dali::DaliException e) {
89861       {
89862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89863       };
89864     } catch (...) {
89865       {
89866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89867       };
89868     }
89869   }
89870
89871 }
89872
89873
89874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89875   int jresult ;
89876   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89877   Dali::Property::Index result;
89878
89879   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89880   {
89881     try {
89882       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89883     } catch (std::out_of_range& e) {
89884       {
89885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89886       };
89887     } catch (std::exception& e) {
89888       {
89889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89890       };
89891     } catch (Dali::DaliException e) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89894       };
89895     } catch (...) {
89896       {
89897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89898       };
89899     }
89900   }
89901
89902   jresult = result;
89903   return jresult;
89904 }
89905
89906
89907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89908   void * jresult ;
89909   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89910   Dali::FrameBufferImage result;
89911
89912   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89913   {
89914     try {
89915       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (Dali::DaliException e) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89927       };
89928     } catch (...) {
89929       {
89930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89931       };
89932     }
89933   }
89934
89935   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89936   return jresult;
89937 }
89938
89939
89940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89941   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89942   Dali::Vector4 *arg2 = 0 ;
89943
89944   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89945   arg2 = (Dali::Vector4 *)jarg2;
89946   if (!arg2) {
89947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89948     return ;
89949   }
89950   {
89951     try {
89952       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89953     } catch (std::out_of_range& e) {
89954       {
89955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89956       };
89957     } catch (std::exception& e) {
89958       {
89959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89960       };
89961     } catch (Dali::DaliException e) {
89962       {
89963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89964       };
89965     } catch (...) {
89966       {
89967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89968       };
89969     }
89970   }
89971
89972 }
89973
89974
89975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89976   void * jresult ;
89977   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89978   Dali::Vector4 result;
89979
89980   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89981   {
89982     try {
89983       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89984     } catch (std::out_of_range& e) {
89985       {
89986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89987       };
89988     } catch (std::exception& e) {
89989       {
89990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89991       };
89992     } catch (Dali::DaliException e) {
89993       {
89994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89995       };
89996     } catch (...) {
89997       {
89998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89999       };
90000     }
90001   }
90002
90003   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90004   return jresult;
90005 }
90006
90007
90008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90009   void * jresult ;
90010   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90011   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90012
90013   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90014   {
90015     try {
90016       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90017     } catch (std::out_of_range& e) {
90018       {
90019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90020       };
90021     } catch (std::exception& e) {
90022       {
90023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90024       };
90025     } catch (Dali::DaliException e) {
90026       {
90027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90028       };
90029     } catch (...) {
90030       {
90031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90032       };
90033     }
90034   }
90035
90036   jresult = (void *)result;
90037   return jresult;
90038 }
90039
90040
90041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90042   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90043
90044   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90045   {
90046     try {
90047       delete arg1;
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90055       };
90056     } catch (Dali::DaliException e) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90059       };
90060     } catch (...) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90063       };
90064     }
90065   }
90066
90067 }
90068
90069
90070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90071   unsigned int jresult ;
90072   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90073   unsigned int result;
90074
90075   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90076   {
90077     try {
90078       result = (unsigned int)(arg1)->GetNumberOfPages();
90079     } catch (std::out_of_range& e) {
90080       {
90081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90082       };
90083     } catch (std::exception& e) {
90084       {
90085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90086       };
90087     } catch (Dali::DaliException e) {
90088       {
90089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90090       };
90091     } catch (...) {
90092       {
90093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90094       };
90095     }
90096   }
90097
90098   jresult = result;
90099   return jresult;
90100 }
90101
90102
90103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90104   void * jresult ;
90105   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90106   unsigned int arg2 ;
90107   Dali::Texture result;
90108
90109   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90110   arg2 = (unsigned int)jarg2;
90111   {
90112     try {
90113       result = (arg1)->NewPage(arg2);
90114     } catch (std::out_of_range& e) {
90115       {
90116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (std::exception& e) {
90119       {
90120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90121       };
90122     } catch (Dali::DaliException e) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90125       };
90126     } catch (...) {
90127       {
90128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90129       };
90130     }
90131   }
90132
90133   jresult = new Dali::Texture((const Dali::Texture &)result);
90134   return jresult;
90135 }
90136
90137
90138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90139   int jresult ;
90140   int result;
90141
90142   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90143   jresult = (int)result;
90144   return jresult;
90145 }
90146
90147
90148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90149   int jresult ;
90150   int result;
90151
90152   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90153   jresult = (int)result;
90154   return jresult;
90155 }
90156
90157
90158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90159   int jresult ;
90160   int result;
90161
90162   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90163   jresult = (int)result;
90164   return jresult;
90165 }
90166
90167
90168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90169   void * jresult ;
90170   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90171
90172   {
90173     try {
90174       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90175     } catch (std::out_of_range& e) {
90176       {
90177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90178       };
90179     } catch (std::exception& e) {
90180       {
90181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90182       };
90183     } catch (Dali::DaliException e) {
90184       {
90185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90186       };
90187     } catch (...) {
90188       {
90189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90190       };
90191     }
90192   }
90193
90194   jresult = (void *)result;
90195   return jresult;
90196 }
90197
90198
90199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90200   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90201
90202   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90203   {
90204     try {
90205       delete arg1;
90206     } catch (std::out_of_range& e) {
90207       {
90208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90209       };
90210     } catch (std::exception& e) {
90211       {
90212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90213       };
90214     } catch (Dali::DaliException e) {
90215       {
90216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90217       };
90218     } catch (...) {
90219       {
90220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90221       };
90222     }
90223   }
90224
90225 }
90226
90227
90228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90229   void * jresult ;
90230   Dali::Toolkit::PageTurnView *result = 0 ;
90231
90232   {
90233     try {
90234       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90235     } catch (std::out_of_range& e) {
90236       {
90237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90238       };
90239     } catch (std::exception& e) {
90240       {
90241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90242       };
90243     } catch (Dali::DaliException e) {
90244       {
90245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90250       };
90251     }
90252   }
90253
90254   jresult = (void *)result;
90255   return jresult;
90256 }
90257
90258
90259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90260   void * jresult ;
90261   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90262   Dali::Toolkit::PageTurnView *result = 0 ;
90263
90264   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90265   if (!arg1) {
90266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90267     return 0;
90268   }
90269   {
90270     try {
90271       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90272     } catch (std::out_of_range& e) {
90273       {
90274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (std::exception& e) {
90277       {
90278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90279       };
90280     } catch (Dali::DaliException e) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90283       };
90284     } catch (...) {
90285       {
90286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90287       };
90288     }
90289   }
90290
90291   jresult = (void *)result;
90292   return jresult;
90293 }
90294
90295
90296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90297   void * jresult ;
90298   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90299   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90300   Dali::Toolkit::PageTurnView *result = 0 ;
90301
90302   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90303   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90304   if (!arg2) {
90305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90306     return 0;
90307   }
90308   {
90309     try {
90310       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90311     } catch (std::out_of_range& e) {
90312       {
90313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90314       };
90315     } catch (std::exception& e) {
90316       {
90317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90318       };
90319     } catch (Dali::DaliException e) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90322       };
90323     } catch (...) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90326       };
90327     }
90328   }
90329
90330   jresult = (void *)result;
90331   return jresult;
90332 }
90333
90334
90335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90336   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90337
90338   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90339   {
90340     try {
90341       delete arg1;
90342     } catch (std::out_of_range& e) {
90343       {
90344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (std::exception& e) {
90347       {
90348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90349       };
90350     } catch (Dali::DaliException e) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90357       };
90358     }
90359   }
90360
90361 }
90362
90363
90364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90365   void * jresult ;
90366   Dali::BaseHandle arg1 ;
90367   Dali::BaseHandle *argp1 ;
90368   Dali::Toolkit::PageTurnView result;
90369
90370   argp1 = (Dali::BaseHandle *)jarg1;
90371   if (!argp1) {
90372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90373     return 0;
90374   }
90375   arg1 = *argp1;
90376   {
90377     try {
90378       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90379     } catch (std::out_of_range& e) {
90380       {
90381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90382       };
90383     } catch (std::exception& e) {
90384       {
90385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90386       };
90387     } catch (Dali::DaliException e) {
90388       {
90389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90390       };
90391     } catch (...) {
90392       {
90393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90394       };
90395     }
90396   }
90397
90398   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90399   return jresult;
90400 }
90401
90402
90403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90404   void * jresult ;
90405   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90406   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90407
90408   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90409   {
90410     try {
90411       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90412     } catch (std::out_of_range& e) {
90413       {
90414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90415       };
90416     } catch (std::exception& e) {
90417       {
90418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90419       };
90420     } catch (Dali::DaliException e) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90423       };
90424     } catch (...) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90427       };
90428     }
90429   }
90430
90431   jresult = (void *)result;
90432   return jresult;
90433 }
90434
90435
90436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90437   void * jresult ;
90438   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90439   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90440
90441   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90442   {
90443     try {
90444       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90445     } catch (std::out_of_range& e) {
90446       {
90447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90448       };
90449     } catch (std::exception& e) {
90450       {
90451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90452       };
90453     } catch (Dali::DaliException e) {
90454       {
90455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90456       };
90457     } catch (...) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90460       };
90461     }
90462   }
90463
90464   jresult = (void *)result;
90465   return jresult;
90466 }
90467
90468
90469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90470   void * jresult ;
90471   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90472   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90473
90474   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90475   {
90476     try {
90477       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90493       };
90494     }
90495   }
90496
90497   jresult = (void *)result;
90498   return jresult;
90499 }
90500
90501
90502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90503   void * jresult ;
90504   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90505   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90506
90507   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90508   {
90509     try {
90510       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90511     } catch (std::out_of_range& e) {
90512       {
90513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90514       };
90515     } catch (std::exception& e) {
90516       {
90517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90518       };
90519     } catch (Dali::DaliException e) {
90520       {
90521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90522       };
90523     } catch (...) {
90524       {
90525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90526       };
90527     }
90528   }
90529
90530   jresult = (void *)result;
90531   return jresult;
90532 }
90533
90534
90535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90536   void * jresult ;
90537   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90538
90539   {
90540     try {
90541       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (Dali::DaliException e) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90553       };
90554     } catch (...) {
90555       {
90556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90557       };
90558     }
90559   }
90560
90561   jresult = (void *)result;
90562   return jresult;
90563 }
90564
90565
90566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90567   void * jresult ;
90568   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90569   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90570
90571   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90572   if (!arg1) {
90573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90574     return 0;
90575   }
90576   {
90577     try {
90578       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90579     } catch (std::out_of_range& e) {
90580       {
90581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90582       };
90583     } catch (std::exception& e) {
90584       {
90585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90586       };
90587     } catch (Dali::DaliException e) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90590       };
90591     } catch (...) {
90592       {
90593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90594       };
90595     }
90596   }
90597
90598   jresult = (void *)result;
90599   return jresult;
90600 }
90601
90602
90603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90604   void * jresult ;
90605   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90606   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90607   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90608
90609   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90610   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90611   if (!arg2) {
90612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90613     return 0;
90614   }
90615   {
90616     try {
90617       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90625       };
90626     } catch (Dali::DaliException e) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90629       };
90630     } catch (...) {
90631       {
90632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90633       };
90634     }
90635   }
90636
90637   jresult = (void *)result;
90638   return jresult;
90639 }
90640
90641
90642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90643   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90644
90645   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90646   {
90647     try {
90648       delete arg1;
90649     } catch (std::out_of_range& e) {
90650       {
90651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90652       };
90653     } catch (std::exception& e) {
90654       {
90655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90656       };
90657     } catch (Dali::DaliException e) {
90658       {
90659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90660       };
90661     } catch (...) {
90662       {
90663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90664       };
90665     }
90666   }
90667
90668 }
90669
90670
90671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90672   void * jresult ;
90673   Dali::Toolkit::PageFactory *arg1 = 0 ;
90674   Dali::Vector2 *arg2 = 0 ;
90675   Dali::Toolkit::PageTurnLandscapeView result;
90676
90677   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90678   if (!arg1) {
90679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90680     return 0;
90681   }
90682   arg2 = (Dali::Vector2 *)jarg2;
90683   if (!arg2) {
90684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90685     return 0;
90686   }
90687   {
90688     try {
90689       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90690     } catch (std::out_of_range& e) {
90691       {
90692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90693       };
90694     } catch (std::exception& e) {
90695       {
90696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90697       };
90698     } catch (Dali::DaliException e) {
90699       {
90700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90701       };
90702     } catch (...) {
90703       {
90704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90705       };
90706     }
90707   }
90708
90709   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90710   return jresult;
90711 }
90712
90713
90714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90715   void * jresult ;
90716   Dali::BaseHandle arg1 ;
90717   Dali::BaseHandle *argp1 ;
90718   Dali::Toolkit::PageTurnLandscapeView result;
90719
90720   argp1 = (Dali::BaseHandle *)jarg1;
90721   if (!argp1) {
90722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90723     return 0;
90724   }
90725   arg1 = *argp1;
90726   {
90727     try {
90728       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90729     } catch (std::out_of_range& e) {
90730       {
90731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90732       };
90733     } catch (std::exception& e) {
90734       {
90735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90736       };
90737     } catch (Dali::DaliException e) {
90738       {
90739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90740       };
90741     } catch (...) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90744       };
90745     }
90746   }
90747
90748   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90749   return jresult;
90750 }
90751
90752
90753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90754   void * jresult ;
90755   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90756
90757   {
90758     try {
90759       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90760     } catch (std::out_of_range& e) {
90761       {
90762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90763       };
90764     } catch (std::exception& e) {
90765       {
90766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90767       };
90768     } catch (Dali::DaliException e) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90771       };
90772     } catch (...) {
90773       {
90774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90775       };
90776     }
90777   }
90778
90779   jresult = (void *)result;
90780   return jresult;
90781 }
90782
90783
90784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90785   void * jresult ;
90786   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90787   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90788
90789   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90790   if (!arg1) {
90791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90792     return 0;
90793   }
90794   {
90795     try {
90796       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90797     } catch (std::out_of_range& e) {
90798       {
90799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90800       };
90801     } catch (std::exception& e) {
90802       {
90803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90804       };
90805     } catch (Dali::DaliException e) {
90806       {
90807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90808       };
90809     } catch (...) {
90810       {
90811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90812       };
90813     }
90814   }
90815
90816   jresult = (void *)result;
90817   return jresult;
90818 }
90819
90820
90821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90822   void * jresult ;
90823   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90824   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90825   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90826
90827   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90828   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90829   if (!arg2) {
90830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90831     return 0;
90832   }
90833   {
90834     try {
90835       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90836     } catch (std::out_of_range& e) {
90837       {
90838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90839       };
90840     } catch (std::exception& e) {
90841       {
90842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90843       };
90844     } catch (Dali::DaliException e) {
90845       {
90846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90847       };
90848     } catch (...) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90851       };
90852     }
90853   }
90854
90855   jresult = (void *)result;
90856   return jresult;
90857 }
90858
90859
90860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90861   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90862
90863   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90864   {
90865     try {
90866       delete arg1;
90867     } catch (std::out_of_range& e) {
90868       {
90869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90870       };
90871     } catch (std::exception& e) {
90872       {
90873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90874       };
90875     } catch (Dali::DaliException e) {
90876       {
90877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90878       };
90879     } catch (...) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90882       };
90883     }
90884   }
90885
90886 }
90887
90888
90889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90890   void * jresult ;
90891   Dali::Toolkit::PageFactory *arg1 = 0 ;
90892   Dali::Vector2 *arg2 = 0 ;
90893   Dali::Toolkit::PageTurnPortraitView result;
90894
90895   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90896   if (!arg1) {
90897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90898     return 0;
90899   }
90900   arg2 = (Dali::Vector2 *)jarg2;
90901   if (!arg2) {
90902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90903     return 0;
90904   }
90905   {
90906     try {
90907       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90915       };
90916     } catch (Dali::DaliException e) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90919       };
90920     } catch (...) {
90921       {
90922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90923       };
90924     }
90925   }
90926
90927   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90928   return jresult;
90929 }
90930
90931
90932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90933   void * jresult ;
90934   Dali::BaseHandle arg1 ;
90935   Dali::BaseHandle *argp1 ;
90936   Dali::Toolkit::PageTurnPortraitView result;
90937
90938   argp1 = (Dali::BaseHandle *)jarg1;
90939   if (!argp1) {
90940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90941     return 0;
90942   }
90943   arg1 = *argp1;
90944   {
90945     try {
90946       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90947     } catch (std::out_of_range& e) {
90948       {
90949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90950       };
90951     } catch (std::exception& e) {
90952       {
90953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90954       };
90955     } catch (Dali::DaliException e) {
90956       {
90957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90958       };
90959     } catch (...) {
90960       {
90961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90962       };
90963     }
90964   }
90965
90966   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90967   return jresult;
90968 }
90969
90970
90971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90972   int jresult ;
90973   int result;
90974
90975   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90976   jresult = (int)result;
90977   return jresult;
90978 }
90979
90980
90981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90982   int jresult ;
90983   int result;
90984
90985   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90986   jresult = (int)result;
90987   return jresult;
90988 }
90989
90990
90991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90992   int jresult ;
90993   int result;
90994
90995   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90996   jresult = (int)result;
90997   return jresult;
90998 }
90999
91000
91001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91002   void * jresult ;
91003   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91004
91005   {
91006     try {
91007       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91008     } catch (std::out_of_range& e) {
91009       {
91010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91011       };
91012     } catch (std::exception& e) {
91013       {
91014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91015       };
91016     } catch (Dali::DaliException e) {
91017       {
91018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91019       };
91020     } catch (...) {
91021       {
91022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91023       };
91024     }
91025   }
91026
91027   jresult = (void *)result;
91028   return jresult;
91029 }
91030
91031
91032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91033   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91034
91035   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91036   {
91037     try {
91038       delete arg1;
91039     } catch (std::out_of_range& e) {
91040       {
91041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91042       };
91043     } catch (std::exception& e) {
91044       {
91045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91046       };
91047     } catch (Dali::DaliException e) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91050       };
91051     } catch (...) {
91052       {
91053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91054       };
91055     }
91056   }
91057
91058 }
91059
91060
91061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91062   void * jresult ;
91063   Dali::Toolkit::ToggleButton *result = 0 ;
91064
91065   {
91066     try {
91067       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91068     } catch (std::out_of_range& e) {
91069       {
91070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91071       };
91072     } catch (std::exception& e) {
91073       {
91074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91075       };
91076     } catch (Dali::DaliException e) {
91077       {
91078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91079       };
91080     } catch (...) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91083       };
91084     }
91085   }
91086
91087   jresult = (void *)result;
91088   return jresult;
91089 }
91090
91091
91092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91093   void * jresult ;
91094   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91095   Dali::Toolkit::ToggleButton *result = 0 ;
91096
91097   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91098   if (!arg1) {
91099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91100     return 0;
91101   }
91102   {
91103     try {
91104       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91105     } catch (std::out_of_range& e) {
91106       {
91107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91108       };
91109     } catch (std::exception& e) {
91110       {
91111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91112       };
91113     } catch (Dali::DaliException e) {
91114       {
91115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91116       };
91117     } catch (...) {
91118       {
91119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91120       };
91121     }
91122   }
91123
91124   jresult = (void *)result;
91125   return jresult;
91126 }
91127
91128
91129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91130   void * jresult ;
91131   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91132   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91133   Dali::Toolkit::ToggleButton *result = 0 ;
91134
91135   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91136   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91137   if (!arg2) {
91138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91139     return 0;
91140   }
91141   {
91142     try {
91143       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (Dali::DaliException e) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91155       };
91156     } catch (...) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91159       };
91160     }
91161   }
91162
91163   jresult = (void *)result;
91164   return jresult;
91165 }
91166
91167
91168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91169   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91170
91171   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91172   {
91173     try {
91174       delete arg1;
91175     } catch (std::out_of_range& e) {
91176       {
91177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91178       };
91179     } catch (std::exception& e) {
91180       {
91181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91182       };
91183     } catch (Dali::DaliException e) {
91184       {
91185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91186       };
91187     } catch (...) {
91188       {
91189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91190       };
91191     }
91192   }
91193
91194 }
91195
91196
91197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91198   void * jresult ;
91199   Dali::Toolkit::ToggleButton result;
91200
91201   {
91202     try {
91203       result = Dali::Toolkit::ToggleButton::New();
91204     } catch (std::out_of_range& e) {
91205       {
91206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91207       };
91208     } catch (std::exception& e) {
91209       {
91210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91211       };
91212     } catch (Dali::DaliException e) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91215       };
91216     } catch (...) {
91217       {
91218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91219       };
91220     }
91221   }
91222
91223   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91224   return jresult;
91225 }
91226
91227
91228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91229   void * jresult ;
91230   Dali::BaseHandle arg1 ;
91231   Dali::BaseHandle *argp1 ;
91232   Dali::Toolkit::ToggleButton result;
91233
91234   argp1 = (Dali::BaseHandle *)jarg1;
91235   if (!argp1) {
91236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91237     return 0;
91238   }
91239   arg1 = *argp1;
91240   {
91241     try {
91242       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91243     } catch (std::out_of_range& e) {
91244       {
91245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91246       };
91247     } catch (std::exception& e) {
91248       {
91249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91250       };
91251     } catch (Dali::DaliException e) {
91252       {
91253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91254       };
91255     } catch (...) {
91256       {
91257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91258       };
91259     }
91260   }
91261
91262   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91263   return jresult;
91264 }
91265
91266
91267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91268   void * jresult ;
91269   Dali::Toolkit::Visual::Base *result = 0 ;
91270
91271   {
91272     try {
91273       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91274     } catch (std::out_of_range& e) {
91275       {
91276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91277       };
91278     } catch (std::exception& e) {
91279       {
91280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91281       };
91282     } catch (Dali::DaliException e) {
91283       {
91284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91285       };
91286     } catch (...) {
91287       {
91288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91289       };
91290     }
91291   }
91292
91293   jresult = (void *)result;
91294   return jresult;
91295 }
91296
91297
91298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91299   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91300
91301   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91302   {
91303     try {
91304       delete arg1;
91305     } catch (std::out_of_range& e) {
91306       {
91307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91308       };
91309     } catch (std::exception& e) {
91310       {
91311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91312       };
91313     } catch (Dali::DaliException e) {
91314       {
91315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91316       };
91317     } catch (...) {
91318       {
91319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91320       };
91321     }
91322   }
91323
91324 }
91325
91326
91327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91328   void * jresult ;
91329   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91330   Dali::Toolkit::Visual::Base *result = 0 ;
91331
91332   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91333   if (!arg1) {
91334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91335     return 0;
91336   }
91337   {
91338     try {
91339       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91340     } catch (std::out_of_range& e) {
91341       {
91342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91343       };
91344     } catch (std::exception& e) {
91345       {
91346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91347       };
91348     } catch (Dali::DaliException e) {
91349       {
91350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91351       };
91352     } catch (...) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91355       };
91356     }
91357   }
91358
91359   jresult = (void *)result;
91360   return jresult;
91361 }
91362
91363
91364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91365   void * jresult ;
91366   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91367   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91368   Dali::Toolkit::Visual::Base *result = 0 ;
91369
91370   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91371   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91372   if (!arg2) {
91373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91374     return 0;
91375   }
91376   {
91377     try {
91378       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91379     } catch (std::out_of_range& e) {
91380       {
91381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91382       };
91383     } catch (std::exception& e) {
91384       {
91385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91386       };
91387     } catch (Dali::DaliException e) {
91388       {
91389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91390       };
91391     } catch (...) {
91392       {
91393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91394       };
91395     }
91396   }
91397
91398   jresult = (void *)result;
91399   return jresult;
91400 }
91401
91402
91403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91404   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91405   std::string *arg2 = 0 ;
91406
91407   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91408   if (!jarg2) {
91409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91410     return ;
91411   }
91412   std::string arg2_str(jarg2);
91413   arg2 = &arg2_str;
91414   {
91415     try {
91416       (arg1)->SetName((std::string const &)*arg2);
91417     } catch (std::out_of_range& e) {
91418       {
91419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91420       };
91421     } catch (std::exception& e) {
91422       {
91423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91424       };
91425     } catch (Dali::DaliException e) {
91426       {
91427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91428       };
91429     } catch (...) {
91430       {
91431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91432       };
91433     }
91434   }
91435
91436
91437   //argout typemap for const std::string&
91438
91439 }
91440
91441
91442 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91443   char * jresult ;
91444   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91445   std::string *result = 0 ;
91446
91447   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91448   {
91449     try {
91450       result = (std::string *) &(arg1)->GetName();
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = SWIG_csharp_string_callback(result->c_str());
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91476   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91477   Dali::Property::Map *arg2 = 0 ;
91478   Dali::Size arg3 ;
91479   Dali::Size *argp3 ;
91480
91481   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91482   arg2 = (Dali::Property::Map *)jarg2;
91483   if (!arg2) {
91484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91485     return ;
91486   }
91487   argp3 = (Dali::Size *)jarg3;
91488   if (!argp3) {
91489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91490     return ;
91491   }
91492   arg3 = *argp3;
91493   {
91494     try {
91495       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91496     } catch (std::out_of_range& e) {
91497       {
91498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91499       };
91500     } catch (std::exception& e) {
91501       {
91502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91503       };
91504     } catch (Dali::DaliException e) {
91505       {
91506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91507       };
91508     } catch (...) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91511       };
91512     }
91513   }
91514
91515 }
91516
91517
91518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91519   float jresult ;
91520   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91521   float arg2 ;
91522   float result;
91523
91524   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91525   arg2 = (float)jarg2;
91526   {
91527     try {
91528       result = (float)(arg1)->GetHeightForWidth(arg2);
91529     } catch (std::out_of_range& e) {
91530       {
91531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91532       };
91533     } catch (std::exception& e) {
91534       {
91535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91536       };
91537     } catch (Dali::DaliException e) {
91538       {
91539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91540       };
91541     } catch (...) {
91542       {
91543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91544       };
91545     }
91546   }
91547
91548   jresult = result;
91549   return jresult;
91550 }
91551
91552
91553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91554   float jresult ;
91555   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91556   float arg2 ;
91557   float result;
91558
91559   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91560   arg2 = (float)jarg2;
91561   {
91562     try {
91563       result = (float)(arg1)->GetWidthForHeight(arg2);
91564     } catch (std::out_of_range& e) {
91565       {
91566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91567       };
91568     } catch (std::exception& e) {
91569       {
91570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91571       };
91572     } catch (Dali::DaliException e) {
91573       {
91574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91575       };
91576     } catch (...) {
91577       {
91578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91579       };
91580     }
91581   }
91582
91583   jresult = result;
91584   return jresult;
91585 }
91586
91587
91588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91589   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91590   Dali::Vector2 *arg2 = 0 ;
91591
91592   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91593   arg2 = (Dali::Vector2 *)jarg2;
91594   if (!arg2) {
91595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91596     return ;
91597   }
91598   {
91599     try {
91600       (arg1)->GetNaturalSize(*arg2);
91601     } catch (std::out_of_range& e) {
91602       {
91603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91604       };
91605     } catch (std::exception& e) {
91606       {
91607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91608       };
91609     } catch (Dali::DaliException e) {
91610       {
91611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91612       };
91613     } catch (...) {
91614       {
91615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91616       };
91617     }
91618   }
91619
91620 }
91621
91622
91623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91624   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91625   float arg2 ;
91626
91627   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91628   arg2 = (int)jarg2;
91629   {
91630     try {
91631       (arg1)->SetDepthIndex(arg2);
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91639       };
91640     } catch (Dali::DaliException e) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91643       };
91644     } catch (...) {
91645       {
91646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91647       };
91648     }
91649   }
91650
91651 }
91652
91653
91654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91655   int jresult ;
91656   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91657   int result;
91658
91659   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91660   {
91661     try {
91662       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91663     } catch (std::out_of_range& e) {
91664       {
91665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91666       };
91667     } catch (std::exception& e) {
91668       {
91669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91670       };
91671     } catch (Dali::DaliException e) {
91672       {
91673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91674       };
91675     } catch (...) {
91676       {
91677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91678       };
91679     }
91680   }
91681
91682   jresult = result;
91683   return jresult;
91684 }
91685
91686
91687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91688   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91689   Dali::Property::Map *arg2 = 0 ;
91690
91691   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91692   arg2 = (Dali::Property::Map *)jarg2;
91693   if (!arg2) {
91694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91695     return ;
91696   }
91697   {
91698     try {
91699       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91700     } catch (std::out_of_range& e) {
91701       {
91702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91703       };
91704     } catch (std::exception& e) {
91705       {
91706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91707       };
91708     } catch (Dali::DaliException e) {
91709       {
91710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91711       };
91712     } catch (...) {
91713       {
91714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91715       };
91716     }
91717   }
91718
91719 }
91720
91721
91722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91723   void * jresult ;
91724   Dali::Toolkit::VisualFactory result;
91725
91726   {
91727     try {
91728       result = Dali::Toolkit::VisualFactory::Get();
91729     } catch (std::out_of_range& e) {
91730       {
91731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91732       };
91733     } catch (std::exception& e) {
91734       {
91735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91736       };
91737     } catch (Dali::DaliException e) {
91738       {
91739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91740       };
91741     } catch (...) {
91742       {
91743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91744       };
91745     }
91746   }
91747
91748   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91749   return jresult;
91750 }
91751
91752
91753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91754   void * jresult ;
91755   Dali::Toolkit::VisualFactory *result = 0 ;
91756
91757   {
91758     try {
91759       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91760     } catch (std::out_of_range& e) {
91761       {
91762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91763       };
91764     } catch (std::exception& e) {
91765       {
91766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91767       };
91768     } catch (Dali::DaliException e) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91771       };
91772     } catch (...) {
91773       {
91774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91775       };
91776     }
91777   }
91778
91779   jresult = (void *)result;
91780   return jresult;
91781 }
91782
91783
91784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91785   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91786
91787   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91788   {
91789     try {
91790       delete arg1;
91791     } catch (std::out_of_range& e) {
91792       {
91793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91794       };
91795     } catch (std::exception& e) {
91796       {
91797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91798       };
91799     } catch (Dali::DaliException e) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91802       };
91803     } catch (...) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91806       };
91807     }
91808   }
91809
91810 }
91811
91812
91813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91814   void * jresult ;
91815   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91816   Dali::Toolkit::VisualFactory *result = 0 ;
91817
91818   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91819   if (!arg1) {
91820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91821     return 0;
91822   }
91823   {
91824     try {
91825       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91826     } catch (std::out_of_range& e) {
91827       {
91828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91829       };
91830     } catch (std::exception& e) {
91831       {
91832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91833       };
91834     } catch (Dali::DaliException e) {
91835       {
91836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91837       };
91838     } catch (...) {
91839       {
91840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91841       };
91842     }
91843   }
91844
91845   jresult = (void *)result;
91846   return jresult;
91847 }
91848
91849
91850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91851   void * jresult ;
91852   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91853   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91854   Dali::Toolkit::VisualFactory *result = 0 ;
91855
91856   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91857   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91858   if (!arg2) {
91859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91860     return 0;
91861   }
91862   {
91863     try {
91864       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91865     } catch (std::out_of_range& e) {
91866       {
91867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91868       };
91869     } catch (std::exception& e) {
91870       {
91871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91872       };
91873     } catch (Dali::DaliException e) {
91874       {
91875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91876       };
91877     } catch (...) {
91878       {
91879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91880       };
91881     }
91882   }
91883
91884   jresult = (void *)result;
91885   return jresult;
91886 }
91887
91888
91889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91890   void * jresult ;
91891   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91892   Dali::Property::Map *arg2 = 0 ;
91893   Dali::Toolkit::Visual::Base result;
91894
91895   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91896   arg2 = (Dali::Property::Map *)jarg2;
91897   if (!arg2) {
91898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91899     return 0;
91900   }
91901   {
91902     try {
91903       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91904     } catch (std::out_of_range& e) {
91905       {
91906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91907       };
91908     } catch (std::exception& e) {
91909       {
91910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91911       };
91912     } catch (Dali::DaliException e) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91915       };
91916     } catch (...) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91919       };
91920     }
91921   }
91922
91923   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91924   return jresult;
91925 }
91926
91927
91928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91929   void * jresult ;
91930   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91931   Dali::Image *arg2 = 0 ;
91932   Dali::Toolkit::Visual::Base result;
91933
91934   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91935   arg2 = (Dali::Image *)jarg2;
91936   if (!arg2) {
91937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91938     return 0;
91939   }
91940   {
91941     try {
91942       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91943     } catch (std::out_of_range& e) {
91944       {
91945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91946       };
91947     } catch (std::exception& e) {
91948       {
91949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (Dali::DaliException e) {
91952       {
91953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91954       };
91955     } catch (...) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91958       };
91959     }
91960   }
91961
91962   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91963   return jresult;
91964 }
91965
91966
91967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91968   void * jresult ;
91969   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91970   std::string *arg2 = 0 ;
91971   Dali::ImageDimensions arg3 ;
91972   Dali::ImageDimensions *argp3 ;
91973   Dali::Toolkit::Visual::Base result;
91974
91975   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91976   if (!jarg2) {
91977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91978     return 0;
91979   }
91980   std::string arg2_str(jarg2);
91981   arg2 = &arg2_str;
91982   argp3 = (Dali::ImageDimensions *)jarg3;
91983   if (!argp3) {
91984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91985     return 0;
91986   }
91987   arg3 = *argp3;
91988   {
91989     try {
91990       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91991     } catch (std::out_of_range& e) {
91992       {
91993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91994       };
91995     } catch (std::exception& e) {
91996       {
91997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (Dali::DaliException e) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92002       };
92003     } catch (...) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92006       };
92007     }
92008   }
92009
92010   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92011
92012   //argout typemap for const std::string&
92013
92014   return jresult;
92015 }
92016
92017
92018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92019   void * jresult ;
92020   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92021
92022   {
92023     try {
92024       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92025     } catch (std::out_of_range& e) {
92026       {
92027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92028       };
92029     } catch (std::exception& e) {
92030       {
92031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92032       };
92033     } catch (Dali::DaliException e) {
92034       {
92035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92036       };
92037     } catch (...) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92040       };
92041     }
92042   }
92043
92044   jresult = (void *)result;
92045   return jresult;
92046 }
92047
92048
92049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92050   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92051
92052   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92053   {
92054     try {
92055       delete arg1;
92056     } catch (std::out_of_range& e) {
92057       {
92058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92059       };
92060     } catch (std::exception& e) {
92061       {
92062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92063       };
92064     } catch (Dali::DaliException e) {
92065       {
92066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92067       };
92068     } catch (...) {
92069       {
92070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92071       };
92072     }
92073   }
92074
92075 }
92076
92077
92078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92079   void * jresult ;
92080   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92081   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92082
92083   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92084   if (!arg1) {
92085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92086     return 0;
92087   }
92088   {
92089     try {
92090       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92091     } catch (std::out_of_range& e) {
92092       {
92093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92094       };
92095     } catch (std::exception& e) {
92096       {
92097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92098       };
92099     } catch (Dali::DaliException e) {
92100       {
92101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92102       };
92103     } catch (...) {
92104       {
92105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92106       };
92107     }
92108   }
92109
92110   jresult = (void *)result;
92111   return jresult;
92112 }
92113
92114
92115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92116   void * jresult ;
92117   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92118   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92119   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92120
92121   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92122   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92123   if (!arg2) {
92124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92125     return 0;
92126   }
92127   {
92128     try {
92129       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92130     } catch (std::out_of_range& e) {
92131       {
92132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92133       };
92134     } catch (std::exception& e) {
92135       {
92136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92137       };
92138     } catch (Dali::DaliException e) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92141       };
92142     } catch (...) {
92143       {
92144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92145       };
92146     }
92147   }
92148
92149   jresult = (void *)result;
92150   return jresult;
92151 }
92152
92153
92154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92155   void * jresult ;
92156   Dali::Toolkit::AsyncImageLoader result;
92157
92158   {
92159     try {
92160       result = Dali::Toolkit::AsyncImageLoader::New();
92161     } catch (std::out_of_range& e) {
92162       {
92163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92164       };
92165     } catch (std::exception& e) {
92166       {
92167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92168       };
92169     } catch (Dali::DaliException e) {
92170       {
92171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92172       };
92173     } catch (...) {
92174       {
92175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92176       };
92177     }
92178   }
92179
92180   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92181   return jresult;
92182 }
92183
92184
92185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92186   void * jresult ;
92187   Dali::BaseHandle arg1 ;
92188   Dali::BaseHandle *argp1 ;
92189   Dali::Toolkit::AsyncImageLoader result;
92190
92191   argp1 = (Dali::BaseHandle *)jarg1;
92192   if (!argp1) {
92193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92194     return 0;
92195   }
92196   arg1 = *argp1;
92197   {
92198     try {
92199       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92200     } catch (std::out_of_range& e) {
92201       {
92202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92203       };
92204     } catch (std::exception& e) {
92205       {
92206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92207       };
92208     } catch (Dali::DaliException e) {
92209       {
92210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92211       };
92212     } catch (...) {
92213       {
92214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92215       };
92216     }
92217   }
92218
92219   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92220   return jresult;
92221 }
92222
92223
92224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92225   unsigned int jresult ;
92226   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92227   std::string *arg2 = 0 ;
92228   uint32_t result;
92229
92230   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92231   if (!jarg2) {
92232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92233     return 0;
92234   }
92235   std::string arg2_str(jarg2);
92236   arg2 = &arg2_str;
92237   {
92238     try {
92239       result = (arg1)->Load((std::string const &)*arg2);
92240     } catch (std::out_of_range& e) {
92241       {
92242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92243       };
92244     } catch (std::exception& e) {
92245       {
92246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92247       };
92248     } catch (Dali::DaliException e) {
92249       {
92250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92251       };
92252     } catch (...) {
92253       {
92254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92255       };
92256     }
92257   }
92258
92259   jresult = result;
92260
92261   //argout typemap for const std::string&
92262
92263   return jresult;
92264 }
92265
92266
92267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92268   unsigned int jresult ;
92269   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92270   std::string *arg2 = 0 ;
92271   Dali::ImageDimensions arg3 ;
92272   Dali::ImageDimensions *argp3 ;
92273   uint32_t result;
92274
92275   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92276   if (!jarg2) {
92277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92278     return 0;
92279   }
92280   std::string arg2_str(jarg2);
92281   arg2 = &arg2_str;
92282   argp3 = (Dali::ImageDimensions *)jarg3;
92283   if (!argp3) {
92284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92285     return 0;
92286   }
92287   arg3 = *argp3;
92288   {
92289     try {
92290       result = (arg1)->Load((std::string const &)*arg2,arg3);
92291     } catch (std::out_of_range& e) {
92292       {
92293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (std::exception& e) {
92296       {
92297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92298       };
92299     } catch (Dali::DaliException e) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92302       };
92303     } catch (...) {
92304       {
92305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92306       };
92307     }
92308   }
92309
92310   jresult = result;
92311
92312   //argout typemap for const std::string&
92313
92314   return jresult;
92315 }
92316
92317
92318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92319   unsigned int jresult ;
92320   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92321   std::string *arg2 = 0 ;
92322   Dali::ImageDimensions arg3 ;
92323   Dali::FittingMode::Type arg4 ;
92324   Dali::SamplingMode::Type arg5 ;
92325   bool arg6 ;
92326   Dali::ImageDimensions *argp3 ;
92327   uint32_t result;
92328
92329   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92330   if (!jarg2) {
92331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92332     return 0;
92333   }
92334   std::string arg2_str(jarg2);
92335   arg2 = &arg2_str;
92336   argp3 = (Dali::ImageDimensions *)jarg3;
92337   if (!argp3) {
92338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92339     return 0;
92340   }
92341   arg3 = *argp3;
92342   arg4 = (Dali::FittingMode::Type)jarg4;
92343   arg5 = (Dali::SamplingMode::Type)jarg5;
92344   arg6 = jarg6 ? true : false;
92345   {
92346     try {
92347       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92348     } catch (std::out_of_range& e) {
92349       {
92350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92351       };
92352     } catch (std::exception& e) {
92353       {
92354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92355       };
92356     } catch (Dali::DaliException e) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92359       };
92360     } catch (...) {
92361       {
92362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92363       };
92364     }
92365   }
92366
92367   jresult = result;
92368
92369   //argout typemap for const std::string&
92370
92371   return jresult;
92372 }
92373
92374
92375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92376   unsigned int jresult ;
92377   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92378   uint32_t arg2 ;
92379   bool result;
92380
92381   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92382   arg2 = (uint32_t)jarg2;
92383   {
92384     try {
92385       result = (bool)(arg1)->Cancel(arg2);
92386     } catch (std::out_of_range& e) {
92387       {
92388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92389       };
92390     } catch (std::exception& e) {
92391       {
92392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92393       };
92394     } catch (Dali::DaliException e) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92397       };
92398     } catch (...) {
92399       {
92400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92401       };
92402     }
92403   }
92404
92405   jresult = result;
92406   return jresult;
92407 }
92408
92409
92410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92411   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92412
92413   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92414   {
92415     try {
92416       (arg1)->CancelAll();
92417     } catch (std::out_of_range& e) {
92418       {
92419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92420       };
92421     } catch (std::exception& e) {
92422       {
92423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92424       };
92425     } catch (Dali::DaliException e) {
92426       {
92427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92428       };
92429     } catch (...) {
92430       {
92431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92432       };
92433     }
92434   }
92435
92436 }
92437
92438
92439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92440   void * jresult ;
92441   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92442   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92443
92444   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92445   {
92446     try {
92447       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92448     } catch (std::out_of_range& e) {
92449       {
92450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92451       };
92452     } catch (std::exception& e) {
92453       {
92454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92455       };
92456     } catch (Dali::DaliException e) {
92457       {
92458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92459       };
92460     } catch (...) {
92461       {
92462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92463       };
92464     }
92465   }
92466
92467   jresult = (void *)result;
92468   return jresult;
92469 }
92470
92471
92472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92473   void * jresult ;
92474   std::string *arg1 = 0 ;
92475   Dali::PixelData result;
92476
92477   if (!jarg1) {
92478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92479     return 0;
92480   }
92481   std::string arg1_str(jarg1);
92482   arg1 = &arg1_str;
92483   {
92484     try {
92485       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92486     } catch (std::out_of_range& e) {
92487       {
92488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92489       };
92490     } catch (std::exception& e) {
92491       {
92492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92493       };
92494     } catch (Dali::DaliException e) {
92495       {
92496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92497       };
92498     } catch (...) {
92499       {
92500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92501       };
92502     }
92503   }
92504
92505   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92506
92507   //argout typemap for const std::string&
92508
92509   return jresult;
92510 }
92511
92512
92513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92514   void * jresult ;
92515   std::string *arg1 = 0 ;
92516   Dali::ImageDimensions arg2 ;
92517   Dali::ImageDimensions *argp2 ;
92518   Dali::PixelData result;
92519
92520   if (!jarg1) {
92521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92522     return 0;
92523   }
92524   std::string arg1_str(jarg1);
92525   arg1 = &arg1_str;
92526   argp2 = (Dali::ImageDimensions *)jarg2;
92527   if (!argp2) {
92528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92529     return 0;
92530   }
92531   arg2 = *argp2;
92532   {
92533     try {
92534       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92535     } catch (std::out_of_range& e) {
92536       {
92537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92538       };
92539     } catch (std::exception& e) {
92540       {
92541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92542       };
92543     } catch (Dali::DaliException e) {
92544       {
92545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92546       };
92547     } catch (...) {
92548       {
92549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92550       };
92551     }
92552   }
92553
92554   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92555
92556   //argout typemap for const std::string&
92557
92558   return jresult;
92559 }
92560
92561
92562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92563   void * jresult ;
92564   std::string *arg1 = 0 ;
92565   Dali::ImageDimensions arg2 ;
92566   Dali::FittingMode::Type arg3 ;
92567   Dali::SamplingMode::Type arg4 ;
92568   bool arg5 ;
92569   Dali::ImageDimensions *argp2 ;
92570   Dali::PixelData result;
92571
92572   if (!jarg1) {
92573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92574     return 0;
92575   }
92576   std::string arg1_str(jarg1);
92577   arg1 = &arg1_str;
92578   argp2 = (Dali::ImageDimensions *)jarg2;
92579   if (!argp2) {
92580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92581     return 0;
92582   }
92583   arg2 = *argp2;
92584   arg3 = (Dali::FittingMode::Type)jarg3;
92585   arg4 = (Dali::SamplingMode::Type)jarg4;
92586   arg5 = jarg5 ? true : false;
92587   {
92588     try {
92589       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92590     } catch (std::out_of_range& e) {
92591       {
92592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92593       };
92594     } catch (std::exception& e) {
92595       {
92596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92597       };
92598     } catch (Dali::DaliException e) {
92599       {
92600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92601       };
92602     } catch (...) {
92603       {
92604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92605       };
92606     }
92607   }
92608
92609   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92610
92611   //argout typemap for const std::string&
92612
92613   return jresult;
92614 }
92615
92616
92617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92618   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92619
92620   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92621   {
92622     try {
92623       delete arg1;
92624     } catch (std::out_of_range& e) {
92625       {
92626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92627       };
92628     } catch (std::exception& e) {
92629       {
92630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92631       };
92632     } catch (Dali::DaliException e) {
92633       {
92634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92639       };
92640     }
92641   }
92642
92643 }
92644
92645
92646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92647   void * jresult ;
92648   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92649   Dali::Actor arg2 ;
92650   Dali::Actor arg3 ;
92651   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92652   Dali::Actor *argp2 ;
92653   Dali::Actor *argp3 ;
92654   Dali::Actor result;
92655
92656   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92657   argp2 = (Dali::Actor *)jarg2;
92658   if (!argp2) {
92659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92660     return 0;
92661   }
92662   arg2 = *argp2;
92663   argp3 = (Dali::Actor *)jarg3;
92664   if (!argp3) {
92665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92666     return 0;
92667   }
92668   arg3 = *argp3;
92669   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92670   {
92671     try {
92672       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92688       };
92689     }
92690   }
92691
92692   jresult = new Dali::Actor((const Dali::Actor &)result);
92693   return jresult;
92694 }
92695
92696
92697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92698   void * jresult ;
92699   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92700
92701   {
92702     try {
92703       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92704     } catch (std::out_of_range& e) {
92705       {
92706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92707       };
92708     } catch (std::exception& e) {
92709       {
92710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92711       };
92712     } catch (Dali::DaliException e) {
92713       {
92714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92715       };
92716     } catch (...) {
92717       {
92718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92719       };
92720     }
92721   }
92722
92723   jresult = (void *)result;
92724   return jresult;
92725 }
92726
92727
92728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92729   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92730   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92731   if (director) {
92732     director->swig_connect_director(callback0);
92733   }
92734 }
92735
92736
92737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92738   KeyboardFocusManager arg1 ;
92739   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92740   KeyboardFocusManager *argp1 ;
92741
92742   argp1 = (KeyboardFocusManager *)jarg1;
92743   if (!argp1) {
92744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92745     return ;
92746   }
92747   arg1 = *argp1;
92748   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92749   if (!arg2) {
92750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92751     return ;
92752   }
92753   {
92754     try {
92755       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92756     } catch (std::out_of_range& e) {
92757       {
92758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92759       };
92760     } catch (std::exception& e) {
92761       {
92762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92763       };
92764     } catch (Dali::DaliException e) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92767       };
92768     } catch (...) {
92769       {
92770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92771       };
92772     }
92773   }
92774
92775 }
92776
92777
92778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92779   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92780
92781   arg1 = (std::vector< unsigned int > *)jarg1;
92782   {
92783     try {
92784       (arg1)->clear();
92785     } catch (std::out_of_range& e) {
92786       {
92787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92788       };
92789     } catch (std::exception& e) {
92790       {
92791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92792       };
92793     } catch (Dali::DaliException e) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92796       };
92797     } catch (...) {
92798       {
92799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92800       };
92801     }
92802   }
92803
92804 }
92805
92806
92807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92808   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92809   unsigned int *arg2 = 0 ;
92810   unsigned int temp2 ;
92811
92812   arg1 = (std::vector< unsigned int > *)jarg1;
92813   temp2 = (unsigned int)jarg2;
92814   arg2 = &temp2;
92815   {
92816     try {
92817       (arg1)->push_back((unsigned int const &)*arg2);
92818     } catch (std::out_of_range& e) {
92819       {
92820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92821       };
92822     } catch (std::exception& e) {
92823       {
92824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92825       };
92826     } catch (Dali::DaliException e) {
92827       {
92828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92829       };
92830     } catch (...) {
92831       {
92832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92833       };
92834     }
92835   }
92836
92837 }
92838
92839
92840 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92841   unsigned long jresult ;
92842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92843   std::vector< unsigned int >::size_type result;
92844
92845   arg1 = (std::vector< unsigned int > *)jarg1;
92846   {
92847     try {
92848       result = ((std::vector< unsigned int > const *)arg1)->size();
92849     } catch (std::out_of_range& e) {
92850       {
92851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92852       };
92853     } catch (std::exception& e) {
92854       {
92855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92856       };
92857     } catch (Dali::DaliException e) {
92858       {
92859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92860       };
92861     } catch (...) {
92862       {
92863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92864       };
92865     }
92866   }
92867
92868   jresult = (unsigned long)result;
92869   return jresult;
92870 }
92871
92872
92873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92874   unsigned long jresult ;
92875   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92876   std::vector< unsigned int >::size_type result;
92877
92878   arg1 = (std::vector< unsigned int > *)jarg1;
92879   {
92880     try {
92881       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92882     } catch (std::out_of_range& e) {
92883       {
92884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92885       };
92886     } catch (std::exception& e) {
92887       {
92888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92889       };
92890     } catch (Dali::DaliException e) {
92891       {
92892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92893       };
92894     } catch (...) {
92895       {
92896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92897       };
92898     }
92899   }
92900
92901   jresult = (unsigned long)result;
92902   return jresult;
92903 }
92904
92905
92906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92907   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92908   std::vector< unsigned int >::size_type arg2 ;
92909
92910   arg1 = (std::vector< unsigned int > *)jarg1;
92911   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92912   {
92913     try {
92914       (arg1)->reserve(arg2);
92915     } catch (std::out_of_range& e) {
92916       {
92917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92918       };
92919     } catch (std::exception& e) {
92920       {
92921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92922       };
92923     } catch (Dali::DaliException e) {
92924       {
92925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92926       };
92927     } catch (...) {
92928       {
92929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92930       };
92931     }
92932   }
92933
92934 }
92935
92936
92937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92938   void * jresult ;
92939   std::vector< unsigned int > *result = 0 ;
92940
92941   {
92942     try {
92943       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92944     } catch (std::out_of_range& e) {
92945       {
92946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92947       };
92948     } catch (std::exception& e) {
92949       {
92950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92951       };
92952     } catch (Dali::DaliException e) {
92953       {
92954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92955       };
92956     } catch (...) {
92957       {
92958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92959       };
92960     }
92961   }
92962
92963   jresult = (void *)result;
92964   return jresult;
92965 }
92966
92967
92968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92969   void * jresult ;
92970   std::vector< unsigned int > *arg1 = 0 ;
92971   std::vector< unsigned int > *result = 0 ;
92972
92973   arg1 = (std::vector< unsigned int > *)jarg1;
92974   if (!arg1) {
92975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92976     return 0;
92977   }
92978   {
92979     try {
92980       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92981     } catch (std::out_of_range& e) {
92982       {
92983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92984       };
92985     } catch (std::exception& e) {
92986       {
92987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92988       };
92989     } catch (Dali::DaliException e) {
92990       {
92991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92992       };
92993     } catch (...) {
92994       {
92995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92996       };
92997     }
92998   }
92999
93000   jresult = (void *)result;
93001   return jresult;
93002 }
93003
93004
93005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93006   void * jresult ;
93007   int arg1 ;
93008   std::vector< unsigned int > *result = 0 ;
93009
93010   arg1 = (int)jarg1;
93011   {
93012     try {
93013       try {
93014         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93015       }
93016       catch(std::out_of_range &_e) {
93017         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93018         return 0;
93019       }
93020
93021     } catch (std::out_of_range& e) {
93022       {
93023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93024       };
93025     } catch (std::exception& e) {
93026       {
93027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93028       };
93029     } catch (Dali::DaliException e) {
93030       {
93031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93032       };
93033     } catch (...) {
93034       {
93035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93036       };
93037     }
93038   }
93039
93040   jresult = (void *)result;
93041   return jresult;
93042 }
93043
93044
93045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93046   unsigned int jresult ;
93047   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93048   int arg2 ;
93049   unsigned int result;
93050
93051   arg1 = (std::vector< unsigned int > *)jarg1;
93052   arg2 = (int)jarg2;
93053   {
93054     try {
93055       try {
93056         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93057       }
93058       catch(std::out_of_range &_e) {
93059         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93060         return 0;
93061       }
93062
93063     } catch (std::out_of_range& e) {
93064       {
93065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93066       };
93067     } catch (std::exception& e) {
93068       {
93069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93070       };
93071     } catch (Dali::DaliException e) {
93072       {
93073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93074       };
93075     } catch (...) {
93076       {
93077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93078       };
93079     }
93080   }
93081
93082   jresult = result;
93083   return jresult;
93084 }
93085
93086
93087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93088   unsigned int jresult ;
93089   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93090   int arg2 ;
93091   unsigned int *result = 0 ;
93092
93093   arg1 = (std::vector< unsigned int > *)jarg1;
93094   arg2 = (int)jarg2;
93095   {
93096     try {
93097       try {
93098         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93099       }
93100       catch(std::out_of_range &_e) {
93101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93102         return 0;
93103       }
93104
93105     } catch (std::out_of_range& e) {
93106       {
93107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93108       };
93109     } catch (std::exception& e) {
93110       {
93111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93112       };
93113     } catch (Dali::DaliException e) {
93114       {
93115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93116       };
93117     } catch (...) {
93118       {
93119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93120       };
93121     }
93122   }
93123
93124   jresult = *result;
93125   return jresult;
93126 }
93127
93128
93129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93131   int arg2 ;
93132   unsigned int *arg3 = 0 ;
93133   unsigned int temp3 ;
93134
93135   arg1 = (std::vector< unsigned int > *)jarg1;
93136   arg2 = (int)jarg2;
93137   temp3 = (unsigned int)jarg3;
93138   arg3 = &temp3;
93139   {
93140     try {
93141       try {
93142         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93143       }
93144       catch(std::out_of_range &_e) {
93145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93146         return ;
93147       }
93148
93149     } catch (std::out_of_range& e) {
93150       {
93151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93152       };
93153     } catch (std::exception& e) {
93154       {
93155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93156       };
93157     } catch (Dali::DaliException e) {
93158       {
93159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93160       };
93161     } catch (...) {
93162       {
93163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93164       };
93165     }
93166   }
93167
93168 }
93169
93170
93171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93173   std::vector< unsigned int > *arg2 = 0 ;
93174
93175   arg1 = (std::vector< unsigned int > *)jarg1;
93176   arg2 = (std::vector< unsigned int > *)jarg2;
93177   if (!arg2) {
93178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93179     return ;
93180   }
93181   {
93182     try {
93183       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93184     } catch (std::out_of_range& e) {
93185       {
93186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93187       };
93188     } catch (std::exception& e) {
93189       {
93190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93191       };
93192     } catch (Dali::DaliException e) {
93193       {
93194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93195       };
93196     } catch (...) {
93197       {
93198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93199       };
93200     }
93201   }
93202
93203 }
93204
93205
93206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93207   void * jresult ;
93208   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93209   int arg2 ;
93210   int arg3 ;
93211   std::vector< unsigned int > *result = 0 ;
93212
93213   arg1 = (std::vector< unsigned int > *)jarg1;
93214   arg2 = (int)jarg2;
93215   arg3 = (int)jarg3;
93216   {
93217     try {
93218       try {
93219         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93220       }
93221       catch(std::out_of_range &_e) {
93222         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93223         return 0;
93224       }
93225       catch(std::invalid_argument &_e) {
93226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93227         return 0;
93228       }
93229
93230     } catch (std::out_of_range& e) {
93231       {
93232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93233       };
93234     } catch (std::exception& e) {
93235       {
93236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93237       };
93238     } catch (Dali::DaliException e) {
93239       {
93240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93241       };
93242     } catch (...) {
93243       {
93244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93245       };
93246     }
93247   }
93248
93249   jresult = (void *)result;
93250   return jresult;
93251 }
93252
93253
93254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93255   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93256   int arg2 ;
93257   unsigned int *arg3 = 0 ;
93258   unsigned int temp3 ;
93259
93260   arg1 = (std::vector< unsigned int > *)jarg1;
93261   arg2 = (int)jarg2;
93262   temp3 = (unsigned int)jarg3;
93263   arg3 = &temp3;
93264   {
93265     try {
93266       try {
93267         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93268       }
93269       catch(std::out_of_range &_e) {
93270         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93271         return ;
93272       }
93273
93274     } catch (std::out_of_range& e) {
93275       {
93276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93277       };
93278     } catch (std::exception& e) {
93279       {
93280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93281       };
93282     } catch (Dali::DaliException e) {
93283       {
93284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93285       };
93286     } catch (...) {
93287       {
93288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93289       };
93290     }
93291   }
93292
93293 }
93294
93295
93296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93297   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93298   int arg2 ;
93299   std::vector< unsigned int > *arg3 = 0 ;
93300
93301   arg1 = (std::vector< unsigned int > *)jarg1;
93302   arg2 = (int)jarg2;
93303   arg3 = (std::vector< unsigned int > *)jarg3;
93304   if (!arg3) {
93305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93306     return ;
93307   }
93308   {
93309     try {
93310       try {
93311         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93312       }
93313       catch(std::out_of_range &_e) {
93314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93315         return ;
93316       }
93317
93318     } catch (std::out_of_range& e) {
93319       {
93320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93321       };
93322     } catch (std::exception& e) {
93323       {
93324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93325       };
93326     } catch (Dali::DaliException e) {
93327       {
93328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93329       };
93330     } catch (...) {
93331       {
93332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93333       };
93334     }
93335   }
93336
93337 }
93338
93339
93340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93341   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93342   int arg2 ;
93343
93344   arg1 = (std::vector< unsigned int > *)jarg1;
93345   arg2 = (int)jarg2;
93346   {
93347     try {
93348       try {
93349         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93350       }
93351       catch(std::out_of_range &_e) {
93352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93353         return ;
93354       }
93355
93356     } catch (std::out_of_range& e) {
93357       {
93358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93359       };
93360     } catch (std::exception& e) {
93361       {
93362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93363       };
93364     } catch (Dali::DaliException e) {
93365       {
93366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93367       };
93368     } catch (...) {
93369       {
93370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93371       };
93372     }
93373   }
93374
93375 }
93376
93377
93378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93379   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93380   int arg2 ;
93381   int arg3 ;
93382
93383   arg1 = (std::vector< unsigned int > *)jarg1;
93384   arg2 = (int)jarg2;
93385   arg3 = (int)jarg3;
93386   {
93387     try {
93388       try {
93389         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93390       }
93391       catch(std::out_of_range &_e) {
93392         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93393         return ;
93394       }
93395       catch(std::invalid_argument &_e) {
93396         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93397         return ;
93398       }
93399
93400     } catch (std::out_of_range& e) {
93401       {
93402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93403       };
93404     } catch (std::exception& e) {
93405       {
93406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93407       };
93408     } catch (Dali::DaliException e) {
93409       {
93410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93411       };
93412     } catch (...) {
93413       {
93414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93415       };
93416     }
93417   }
93418
93419 }
93420
93421
93422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93423   void * jresult ;
93424   unsigned int *arg1 = 0 ;
93425   int arg2 ;
93426   unsigned int temp1 ;
93427   std::vector< unsigned int > *result = 0 ;
93428
93429   temp1 = (unsigned int)jarg1;
93430   arg1 = &temp1;
93431   arg2 = (int)jarg2;
93432   {
93433     try {
93434       try {
93435         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93436       }
93437       catch(std::out_of_range &_e) {
93438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93439         return 0;
93440       }
93441
93442     } catch (std::out_of_range& e) {
93443       {
93444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (std::exception& e) {
93447       {
93448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93449       };
93450     } catch (Dali::DaliException e) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93453       };
93454     } catch (...) {
93455       {
93456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93457       };
93458     }
93459   }
93460
93461   jresult = (void *)result;
93462   return jresult;
93463 }
93464
93465
93466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93467   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93468
93469   arg1 = (std::vector< unsigned int > *)jarg1;
93470   {
93471     try {
93472       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93473     } catch (std::out_of_range& e) {
93474       {
93475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93476       };
93477     } catch (std::exception& e) {
93478       {
93479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93480       };
93481     } catch (Dali::DaliException e) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93484       };
93485     } catch (...) {
93486       {
93487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93488       };
93489     }
93490   }
93491
93492 }
93493
93494
93495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93496   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93497   int arg2 ;
93498   int arg3 ;
93499
93500   arg1 = (std::vector< unsigned int > *)jarg1;
93501   arg2 = (int)jarg2;
93502   arg3 = (int)jarg3;
93503   {
93504     try {
93505       try {
93506         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93507       }
93508       catch(std::out_of_range &_e) {
93509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93510         return ;
93511       }
93512       catch(std::invalid_argument &_e) {
93513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93514         return ;
93515       }
93516
93517     } catch (std::out_of_range& e) {
93518       {
93519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93520       };
93521     } catch (std::exception& e) {
93522       {
93523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93524       };
93525     } catch (Dali::DaliException e) {
93526       {
93527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93528       };
93529     } catch (...) {
93530       {
93531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93532       };
93533     }
93534   }
93535
93536 }
93537
93538
93539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93540   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93541   int arg2 ;
93542   std::vector< unsigned int > *arg3 = 0 ;
93543
93544   arg1 = (std::vector< unsigned int > *)jarg1;
93545   arg2 = (int)jarg2;
93546   arg3 = (std::vector< unsigned int > *)jarg3;
93547   if (!arg3) {
93548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93549     return ;
93550   }
93551   {
93552     try {
93553       try {
93554         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93555       }
93556       catch(std::out_of_range &_e) {
93557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93558         return ;
93559       }
93560
93561     } catch (std::out_of_range& e) {
93562       {
93563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93564       };
93565     } catch (std::exception& e) {
93566       {
93567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93568       };
93569     } catch (Dali::DaliException e) {
93570       {
93571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93572       };
93573     } catch (...) {
93574       {
93575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93576       };
93577     }
93578   }
93579
93580 }
93581
93582
93583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93584   unsigned int jresult ;
93585   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93586   unsigned int *arg2 = 0 ;
93587   unsigned int temp2 ;
93588   bool result;
93589
93590   arg1 = (std::vector< unsigned int > *)jarg1;
93591   temp2 = (unsigned int)jarg2;
93592   arg2 = &temp2;
93593   {
93594     try {
93595       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93596     } catch (std::out_of_range& e) {
93597       {
93598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93599       };
93600     } catch (std::exception& e) {
93601       {
93602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93603       };
93604     } catch (Dali::DaliException e) {
93605       {
93606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93607       };
93608     } catch (...) {
93609       {
93610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93611       };
93612     }
93613   }
93614
93615   jresult = result;
93616   return jresult;
93617 }
93618
93619
93620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93621   int jresult ;
93622   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93623   unsigned int *arg2 = 0 ;
93624   unsigned int temp2 ;
93625   int result;
93626
93627   arg1 = (std::vector< unsigned int > *)jarg1;
93628   temp2 = (unsigned int)jarg2;
93629   arg2 = &temp2;
93630   {
93631     try {
93632       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93633     } catch (std::out_of_range& e) {
93634       {
93635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93636       };
93637     } catch (std::exception& e) {
93638       {
93639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93640       };
93641     } catch (Dali::DaliException e) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93644       };
93645     } catch (...) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93648       };
93649     }
93650   }
93651
93652   jresult = result;
93653   return jresult;
93654 }
93655
93656
93657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93658   int jresult ;
93659   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93660   unsigned int *arg2 = 0 ;
93661   unsigned int temp2 ;
93662   int result;
93663
93664   arg1 = (std::vector< unsigned int > *)jarg1;
93665   temp2 = (unsigned int)jarg2;
93666   arg2 = &temp2;
93667   {
93668     try {
93669       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93670     } catch (std::out_of_range& e) {
93671       {
93672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93673       };
93674     } catch (std::exception& e) {
93675       {
93676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93677       };
93678     } catch (Dali::DaliException e) {
93679       {
93680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93681       };
93682     } catch (...) {
93683       {
93684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93685       };
93686     }
93687   }
93688
93689   jresult = result;
93690   return jresult;
93691 }
93692
93693
93694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93695   unsigned int jresult ;
93696   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93697   unsigned int *arg2 = 0 ;
93698   unsigned int temp2 ;
93699   bool result;
93700
93701   arg1 = (std::vector< unsigned int > *)jarg1;
93702   temp2 = (unsigned int)jarg2;
93703   arg2 = &temp2;
93704   {
93705     try {
93706       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93707     } catch (std::out_of_range& e) {
93708       {
93709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93710       };
93711     } catch (std::exception& e) {
93712       {
93713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93714       };
93715     } catch (Dali::DaliException e) {
93716       {
93717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93718       };
93719     } catch (...) {
93720       {
93721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93722       };
93723     }
93724   }
93725
93726   jresult = result;
93727   return jresult;
93728 }
93729
93730
93731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93732   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93733
93734   arg1 = (std::vector< unsigned int > *)jarg1;
93735   {
93736     try {
93737       delete arg1;
93738     } catch (std::out_of_range& e) {
93739       {
93740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93741       };
93742     } catch (std::exception& e) {
93743       {
93744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93745       };
93746     } catch (Dali::DaliException e) {
93747       {
93748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93749       };
93750     } catch (...) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93753       };
93754     }
93755   }
93756
93757 }
93758
93759
93760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93761   void * jresult ;
93762   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93763
93764   {
93765     try {
93766       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93767     } catch (std::out_of_range& e) {
93768       {
93769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93770       };
93771     } catch (std::exception& e) {
93772       {
93773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93774       };
93775     } catch (Dali::DaliException e) {
93776       {
93777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93778       };
93779     } catch (...) {
93780       {
93781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93782       };
93783     }
93784   }
93785
93786   jresult = (void *)result;
93787   return jresult;
93788 }
93789
93790
93791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93792   void * jresult ;
93793   unsigned int arg1 ;
93794   Dali::Actor arg2 ;
93795   Dali::Actor *argp2 ;
93796   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93797
93798   arg1 = (unsigned int)jarg1;
93799   argp2 = (Dali::Actor *)jarg2;
93800   if (!argp2) {
93801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93802     return 0;
93803   }
93804   arg2 = *argp2;
93805   {
93806     try {
93807       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93808     } catch (std::out_of_range& e) {
93809       {
93810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93811       };
93812     } catch (std::exception& e) {
93813       {
93814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93815       };
93816     } catch (Dali::DaliException e) {
93817       {
93818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93819       };
93820     } catch (...) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93823       };
93824     }
93825   }
93826
93827   jresult = (void *)result;
93828   return jresult;
93829 }
93830
93831
93832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93833   void * jresult ;
93834   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93835   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93836
93837   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93838   if (!arg1) {
93839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93840     return 0;
93841   }
93842   {
93843     try {
93844       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93852       };
93853     } catch (Dali::DaliException e) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93856       };
93857     } catch (...) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93860       };
93861     }
93862   }
93863
93864   jresult = (void *)result;
93865   return jresult;
93866 }
93867
93868
93869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93870   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93871   unsigned int arg2 ;
93872
93873   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93874   arg2 = (unsigned int)jarg2;
93875   if (arg1) (arg1)->first = arg2;
93876 }
93877
93878
93879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93880   unsigned int jresult ;
93881   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93882   unsigned int result;
93883
93884   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93885   result = (unsigned int) ((arg1)->first);
93886   jresult = result;
93887   return jresult;
93888 }
93889
93890
93891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93892   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93893   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93894
93895   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93896   arg2 = (Dali::Actor *)jarg2;
93897   if (arg1) (arg1)->second = *arg2;
93898 }
93899
93900
93901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93902   void * jresult ;
93903   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93904   Dali::Actor *result = 0 ;
93905
93906   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93907   result = (Dali::Actor *)& ((arg1)->second);
93908   jresult = (void *)result;
93909   return jresult;
93910 }
93911
93912
93913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93914   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93915
93916   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93917   {
93918     try {
93919       delete arg1;
93920     } catch (std::out_of_range& e) {
93921       {
93922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93923       };
93924     } catch (std::exception& e) {
93925       {
93926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93927       };
93928     } catch (Dali::DaliException e) {
93929       {
93930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93931       };
93932     } catch (...) {
93933       {
93934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93935       };
93936     }
93937   }
93938
93939 }
93940
93941
93942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93943   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93944
93945   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93946   {
93947     try {
93948       (arg1)->clear();
93949     } catch (std::out_of_range& e) {
93950       {
93951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93952       };
93953     } catch (std::exception& e) {
93954       {
93955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93956       };
93957     } catch (Dali::DaliException e) {
93958       {
93959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93960       };
93961     } catch (...) {
93962       {
93963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93964       };
93965     }
93966   }
93967
93968 }
93969
93970
93971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93972   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93973   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93974
93975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93976   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93977   if (!arg2) {
93978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93979     return ;
93980   }
93981   {
93982     try {
93983       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93984     } catch (std::out_of_range& e) {
93985       {
93986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93987       };
93988     } catch (std::exception& e) {
93989       {
93990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93991       };
93992     } catch (Dali::DaliException e) {
93993       {
93994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93995       };
93996     } catch (...) {
93997       {
93998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93999       };
94000     }
94001   }
94002
94003 }
94004
94005
94006 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94007   unsigned long jresult ;
94008   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94009   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94010
94011   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94012   {
94013     try {
94014       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94015     } catch (std::out_of_range& e) {
94016       {
94017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94018       };
94019     } catch (std::exception& e) {
94020       {
94021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94022       };
94023     } catch (Dali::DaliException e) {
94024       {
94025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94026       };
94027     } catch (...) {
94028       {
94029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94030       };
94031     }
94032   }
94033
94034   jresult = (unsigned long)result;
94035   return jresult;
94036 }
94037
94038
94039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94040   unsigned long jresult ;
94041   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94042   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94043
94044   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94045   {
94046     try {
94047       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94048     } catch (std::out_of_range& e) {
94049       {
94050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94051       };
94052     } catch (std::exception& e) {
94053       {
94054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94055       };
94056     } catch (Dali::DaliException e) {
94057       {
94058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94059       };
94060     } catch (...) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94063       };
94064     }
94065   }
94066
94067   jresult = (unsigned long)result;
94068   return jresult;
94069 }
94070
94071
94072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94073   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94074   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94075
94076   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94077   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94078   {
94079     try {
94080       (arg1)->reserve(arg2);
94081     } catch (std::out_of_range& e) {
94082       {
94083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94084       };
94085     } catch (std::exception& e) {
94086       {
94087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (Dali::DaliException e) {
94090       {
94091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94092       };
94093     } catch (...) {
94094       {
94095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94096       };
94097     }
94098   }
94099
94100 }
94101
94102
94103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94104   void * jresult ;
94105   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94106
94107   {
94108     try {
94109       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94110     } catch (std::out_of_range& e) {
94111       {
94112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94113       };
94114     } catch (std::exception& e) {
94115       {
94116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94117       };
94118     } catch (Dali::DaliException e) {
94119       {
94120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94121       };
94122     } catch (...) {
94123       {
94124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94125       };
94126     }
94127   }
94128
94129   jresult = (void *)result;
94130   return jresult;
94131 }
94132
94133
94134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94135   void * jresult ;
94136   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94137   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94138
94139   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94140   if (!arg1) {
94141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94142     return 0;
94143   }
94144   {
94145     try {
94146       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);
94147     } catch (std::out_of_range& e) {
94148       {
94149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94150       };
94151     } catch (std::exception& e) {
94152       {
94153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94154       };
94155     } catch (Dali::DaliException e) {
94156       {
94157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94158       };
94159     } catch (...) {
94160       {
94161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94162       };
94163     }
94164   }
94165
94166   jresult = (void *)result;
94167   return jresult;
94168 }
94169
94170
94171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94172   void * jresult ;
94173   int arg1 ;
94174   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94175
94176   arg1 = (int)jarg1;
94177   {
94178     try {
94179       try {
94180         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);
94181       }
94182       catch(std::out_of_range &_e) {
94183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94184         return 0;
94185       }
94186
94187     } catch (std::out_of_range& e) {
94188       {
94189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94190       };
94191     } catch (std::exception& e) {
94192       {
94193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94194       };
94195     } catch (Dali::DaliException e) {
94196       {
94197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94198       };
94199     } catch (...) {
94200       {
94201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94202       };
94203     }
94204   }
94205
94206   jresult = (void *)result;
94207   return jresult;
94208 }
94209
94210
94211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94212   void * jresult ;
94213   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94214   int arg2 ;
94215   std::pair< unsigned int,Dali::Actor > result;
94216
94217   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94218   arg2 = (int)jarg2;
94219   {
94220     try {
94221       try {
94222         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94223       }
94224       catch(std::out_of_range &_e) {
94225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94226         return 0;
94227       }
94228
94229     } catch (std::out_of_range& e) {
94230       {
94231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94232       };
94233     } catch (std::exception& e) {
94234       {
94235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94236       };
94237     } catch (Dali::DaliException e) {
94238       {
94239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94240       };
94241     } catch (...) {
94242       {
94243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94244       };
94245     }
94246   }
94247
94248   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94249   return jresult;
94250 }
94251
94252
94253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94254   void * jresult ;
94255   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94256   int arg2 ;
94257   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94258
94259   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94260   arg2 = (int)jarg2;
94261   {
94262     try {
94263       try {
94264         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94265       }
94266       catch(std::out_of_range &_e) {
94267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94268         return 0;
94269       }
94270
94271     } catch (std::out_of_range& e) {
94272       {
94273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94274       };
94275     } catch (std::exception& e) {
94276       {
94277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94278       };
94279     } catch (Dali::DaliException e) {
94280       {
94281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94282       };
94283     } catch (...) {
94284       {
94285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94286       };
94287     }
94288   }
94289
94290   jresult = (void *)result;
94291   return jresult;
94292 }
94293
94294
94295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94296   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94297   int arg2 ;
94298   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94299
94300   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94301   arg2 = (int)jarg2;
94302   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94303   if (!arg3) {
94304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94305     return ;
94306   }
94307   {
94308     try {
94309       try {
94310         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);
94311       }
94312       catch(std::out_of_range &_e) {
94313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94314         return ;
94315       }
94316
94317     } catch (std::out_of_range& e) {
94318       {
94319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94320       };
94321     } catch (std::exception& e) {
94322       {
94323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94324       };
94325     } catch (Dali::DaliException e) {
94326       {
94327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94328       };
94329     } catch (...) {
94330       {
94331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94332       };
94333     }
94334   }
94335
94336 }
94337
94338
94339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94340   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94341   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94342
94343   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94344   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94345   if (!arg2) {
94346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94347     return ;
94348   }
94349   {
94350     try {
94351       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);
94352     } catch (std::out_of_range& e) {
94353       {
94354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94355       };
94356     } catch (std::exception& e) {
94357       {
94358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94359       };
94360     } catch (Dali::DaliException e) {
94361       {
94362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94363       };
94364     } catch (...) {
94365       {
94366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94367       };
94368     }
94369   }
94370
94371 }
94372
94373
94374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94375   void * jresult ;
94376   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94377   int arg2 ;
94378   int arg3 ;
94379   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94380
94381   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94382   arg2 = (int)jarg2;
94383   arg3 = (int)jarg3;
94384   {
94385     try {
94386       try {
94387         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);
94388       }
94389       catch(std::out_of_range &_e) {
94390         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94391         return 0;
94392       }
94393       catch(std::invalid_argument &_e) {
94394         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94395         return 0;
94396       }
94397
94398     } catch (std::out_of_range& e) {
94399       {
94400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94401       };
94402     } catch (std::exception& e) {
94403       {
94404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94405       };
94406     } catch (Dali::DaliException e) {
94407       {
94408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94409       };
94410     } catch (...) {
94411       {
94412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94413       };
94414     }
94415   }
94416
94417   jresult = (void *)result;
94418   return jresult;
94419 }
94420
94421
94422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94423   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94424   int arg2 ;
94425   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94426
94427   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94428   arg2 = (int)jarg2;
94429   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94430   if (!arg3) {
94431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94432     return ;
94433   }
94434   {
94435     try {
94436       try {
94437         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);
94438       }
94439       catch(std::out_of_range &_e) {
94440         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94441         return ;
94442       }
94443
94444     } catch (std::out_of_range& e) {
94445       {
94446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94447       };
94448     } catch (std::exception& e) {
94449       {
94450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94451       };
94452     } catch (Dali::DaliException e) {
94453       {
94454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94455       };
94456     } catch (...) {
94457       {
94458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94459       };
94460     }
94461   }
94462
94463 }
94464
94465
94466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94467   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94468   int arg2 ;
94469   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94470
94471   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94472   arg2 = (int)jarg2;
94473   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94474   if (!arg3) {
94475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94476     return ;
94477   }
94478   {
94479     try {
94480       try {
94481         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);
94482       }
94483       catch(std::out_of_range &_e) {
94484         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94485         return ;
94486       }
94487
94488     } catch (std::out_of_range& e) {
94489       {
94490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94491       };
94492     } catch (std::exception& e) {
94493       {
94494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94495       };
94496     } catch (Dali::DaliException e) {
94497       {
94498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94499       };
94500     } catch (...) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94503       };
94504     }
94505   }
94506
94507 }
94508
94509
94510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94511   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94512   int arg2 ;
94513
94514   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94515   arg2 = (int)jarg2;
94516   {
94517     try {
94518       try {
94519         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94520       }
94521       catch(std::out_of_range &_e) {
94522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94523         return ;
94524       }
94525
94526     } catch (std::out_of_range& e) {
94527       {
94528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (std::exception& e) {
94531       {
94532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94533       };
94534     } catch (Dali::DaliException e) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94537       };
94538     } catch (...) {
94539       {
94540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94541       };
94542     }
94543   }
94544
94545 }
94546
94547
94548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94549   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94550   int arg2 ;
94551   int arg3 ;
94552
94553   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94554   arg2 = (int)jarg2;
94555   arg3 = (int)jarg3;
94556   {
94557     try {
94558       try {
94559         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94560       }
94561       catch(std::out_of_range &_e) {
94562         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94563         return ;
94564       }
94565       catch(std::invalid_argument &_e) {
94566         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94567         return ;
94568       }
94569
94570     } catch (std::out_of_range& e) {
94571       {
94572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94573       };
94574     } catch (std::exception& e) {
94575       {
94576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94577       };
94578     } catch (Dali::DaliException e) {
94579       {
94580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94581       };
94582     } catch (...) {
94583       {
94584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94585       };
94586     }
94587   }
94588
94589 }
94590
94591
94592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94593   void * jresult ;
94594   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94595   int arg2 ;
94596   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94597
94598   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94599   if (!arg1) {
94600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94601     return 0;
94602   }
94603   arg2 = (int)jarg2;
94604   {
94605     try {
94606       try {
94607         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);
94608       }
94609       catch(std::out_of_range &_e) {
94610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94611         return 0;
94612       }
94613
94614     } catch (std::out_of_range& e) {
94615       {
94616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94617       };
94618     } catch (std::exception& e) {
94619       {
94620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94621       };
94622     } catch (Dali::DaliException e) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94629       };
94630     }
94631   }
94632
94633   jresult = (void *)result;
94634   return jresult;
94635 }
94636
94637
94638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94639   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94640
94641   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94642   {
94643     try {
94644       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94645     } catch (std::out_of_range& e) {
94646       {
94647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94648       };
94649     } catch (std::exception& e) {
94650       {
94651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94652       };
94653     } catch (Dali::DaliException e) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94656       };
94657     } catch (...) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94660       };
94661     }
94662   }
94663
94664 }
94665
94666
94667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94668   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94669   int arg2 ;
94670   int arg3 ;
94671
94672   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94673   arg2 = (int)jarg2;
94674   arg3 = (int)jarg3;
94675   {
94676     try {
94677       try {
94678         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94679       }
94680       catch(std::out_of_range &_e) {
94681         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94682         return ;
94683       }
94684       catch(std::invalid_argument &_e) {
94685         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94686         return ;
94687       }
94688
94689     } catch (std::out_of_range& e) {
94690       {
94691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94692       };
94693     } catch (std::exception& e) {
94694       {
94695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94696       };
94697     } catch (Dali::DaliException e) {
94698       {
94699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94700       };
94701     } catch (...) {
94702       {
94703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94704       };
94705     }
94706   }
94707
94708 }
94709
94710
94711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94712   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94713   int arg2 ;
94714   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94715
94716   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94717   arg2 = (int)jarg2;
94718   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94719   if (!arg3) {
94720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94721     return ;
94722   }
94723   {
94724     try {
94725       try {
94726         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);
94727       }
94728       catch(std::out_of_range &_e) {
94729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94730         return ;
94731       }
94732
94733     } catch (std::out_of_range& e) {
94734       {
94735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94736       };
94737     } catch (std::exception& e) {
94738       {
94739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94740       };
94741     } catch (Dali::DaliException e) {
94742       {
94743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94744       };
94745     } catch (...) {
94746       {
94747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94748       };
94749     }
94750   }
94751
94752 }
94753
94754
94755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94756   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94757
94758   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94759   {
94760     try {
94761       delete arg1;
94762     } catch (std::out_of_range& e) {
94763       {
94764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94765       };
94766     } catch (std::exception& e) {
94767       {
94768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94769       };
94770     } catch (Dali::DaliException e) {
94771       {
94772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94773       };
94774     } catch (...) {
94775       {
94776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94777       };
94778     }
94779   }
94780
94781 }
94782
94783
94784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94785   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94786
94787   arg1 = (std::vector< Dali::Actor > *)jarg1;
94788   {
94789     try {
94790       (arg1)->clear();
94791     } catch (std::out_of_range& e) {
94792       {
94793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94794       };
94795     } catch (std::exception& e) {
94796       {
94797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94798       };
94799     } catch (Dali::DaliException e) {
94800       {
94801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94802       };
94803     } catch (...) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94806       };
94807     }
94808   }
94809
94810 }
94811
94812
94813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94814   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94815   Dali::Actor *arg2 = 0 ;
94816
94817   arg1 = (std::vector< Dali::Actor > *)jarg1;
94818   arg2 = (Dali::Actor *)jarg2;
94819   if (!arg2) {
94820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94821     return ;
94822   }
94823   {
94824     try {
94825       (arg1)->push_back((Dali::Actor const &)*arg2);
94826     } catch (std::out_of_range& e) {
94827       {
94828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94829       };
94830     } catch (std::exception& e) {
94831       {
94832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94833       };
94834     } catch (Dali::DaliException e) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94837       };
94838     } catch (...) {
94839       {
94840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94841       };
94842     }
94843   }
94844
94845 }
94846
94847
94848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94849   unsigned long jresult ;
94850   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94851   std::vector< Dali::Actor >::size_type result;
94852
94853   arg1 = (std::vector< Dali::Actor > *)jarg1;
94854   {
94855     try {
94856       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94857     } catch (std::out_of_range& e) {
94858       {
94859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94860       };
94861     } catch (std::exception& e) {
94862       {
94863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94864       };
94865     } catch (Dali::DaliException e) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94868       };
94869     } catch (...) {
94870       {
94871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94872       };
94873     }
94874   }
94875
94876   jresult = (unsigned long)result;
94877   return jresult;
94878 }
94879
94880
94881 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94882   unsigned long jresult ;
94883   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94884   std::vector< Dali::Actor >::size_type result;
94885
94886   arg1 = (std::vector< Dali::Actor > *)jarg1;
94887   {
94888     try {
94889       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94890     } catch (std::out_of_range& e) {
94891       {
94892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94893       };
94894     } catch (std::exception& e) {
94895       {
94896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94897       };
94898     } catch (Dali::DaliException e) {
94899       {
94900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94901       };
94902     } catch (...) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94905       };
94906     }
94907   }
94908
94909   jresult = (unsigned long)result;
94910   return jresult;
94911 }
94912
94913
94914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94915   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94916   std::vector< Dali::Actor >::size_type arg2 ;
94917
94918   arg1 = (std::vector< Dali::Actor > *)jarg1;
94919   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94920   {
94921     try {
94922       (arg1)->reserve(arg2);
94923     } catch (std::out_of_range& e) {
94924       {
94925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94926       };
94927     } catch (std::exception& e) {
94928       {
94929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94930       };
94931     } catch (Dali::DaliException e) {
94932       {
94933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94934       };
94935     } catch (...) {
94936       {
94937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94938       };
94939     }
94940   }
94941
94942 }
94943
94944
94945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94946   void * jresult ;
94947   std::vector< Dali::Actor > *result = 0 ;
94948
94949   {
94950     try {
94951       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94952     } catch (std::out_of_range& e) {
94953       {
94954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94955       };
94956     } catch (std::exception& e) {
94957       {
94958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94959       };
94960     } catch (Dali::DaliException e) {
94961       {
94962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94963       };
94964     } catch (...) {
94965       {
94966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94967       };
94968     }
94969   }
94970
94971   jresult = (void *)result;
94972   return jresult;
94973 }
94974
94975
94976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94977   void * jresult ;
94978   std::vector< Dali::Actor > *arg1 = 0 ;
94979   std::vector< Dali::Actor > *result = 0 ;
94980
94981   arg1 = (std::vector< Dali::Actor > *)jarg1;
94982   if (!arg1) {
94983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94984     return 0;
94985   }
94986   {
94987     try {
94988       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94989     } catch (std::out_of_range& e) {
94990       {
94991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94992       };
94993     } catch (std::exception& e) {
94994       {
94995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94996       };
94997     } catch (Dali::DaliException e) {
94998       {
94999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95000       };
95001     } catch (...) {
95002       {
95003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95004       };
95005     }
95006   }
95007
95008   jresult = (void *)result;
95009   return jresult;
95010 }
95011
95012
95013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95014   void * jresult ;
95015   int arg1 ;
95016   std::vector< Dali::Actor > *result = 0 ;
95017
95018   arg1 = (int)jarg1;
95019   {
95020     try {
95021       try {
95022         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95023       }
95024       catch(std::out_of_range &_e) {
95025         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95026         return 0;
95027       }
95028
95029     } catch (std::out_of_range& e) {
95030       {
95031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95032       };
95033     } catch (std::exception& e) {
95034       {
95035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95036       };
95037     } catch (Dali::DaliException e) {
95038       {
95039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95040       };
95041     } catch (...) {
95042       {
95043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95044       };
95045     }
95046   }
95047
95048   jresult = (void *)result;
95049   return jresult;
95050 }
95051
95052
95053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95054   void * jresult ;
95055   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95056   int arg2 ;
95057   Dali::Actor result;
95058
95059   arg1 = (std::vector< Dali::Actor > *)jarg1;
95060   arg2 = (int)jarg2;
95061   {
95062     try {
95063       try {
95064         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95065       }
95066       catch(std::out_of_range &_e) {
95067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95068         return 0;
95069       }
95070
95071     } catch (std::out_of_range& e) {
95072       {
95073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95074       };
95075     } catch (std::exception& e) {
95076       {
95077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95078       };
95079     } catch (Dali::DaliException e) {
95080       {
95081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95082       };
95083     } catch (...) {
95084       {
95085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95086       };
95087     }
95088   }
95089
95090   jresult = new Dali::Actor((const Dali::Actor &)result);
95091   return jresult;
95092 }
95093
95094
95095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95096   void * jresult ;
95097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95098   int arg2 ;
95099   Dali::Actor *result = 0 ;
95100
95101   arg1 = (std::vector< Dali::Actor > *)jarg1;
95102   arg2 = (int)jarg2;
95103   {
95104     try {
95105       try {
95106         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95107       }
95108       catch(std::out_of_range &_e) {
95109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95110         return 0;
95111       }
95112
95113     } catch (std::out_of_range& e) {
95114       {
95115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95116       };
95117     } catch (std::exception& e) {
95118       {
95119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95120       };
95121     } catch (Dali::DaliException e) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95124       };
95125     } catch (...) {
95126       {
95127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95128       };
95129     }
95130   }
95131
95132   jresult = (void *)result;
95133   return jresult;
95134 }
95135
95136
95137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95138   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95139   int arg2 ;
95140   Dali::Actor *arg3 = 0 ;
95141
95142   arg1 = (std::vector< Dali::Actor > *)jarg1;
95143   arg2 = (int)jarg2;
95144   arg3 = (Dali::Actor *)jarg3;
95145   if (!arg3) {
95146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95147     return ;
95148   }
95149   {
95150     try {
95151       try {
95152         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95153       }
95154       catch(std::out_of_range &_e) {
95155         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95156         return ;
95157       }
95158
95159     } catch (std::out_of_range& e) {
95160       {
95161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95162       };
95163     } catch (std::exception& e) {
95164       {
95165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95166       };
95167     } catch (Dali::DaliException e) {
95168       {
95169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95170       };
95171     } catch (...) {
95172       {
95173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95174       };
95175     }
95176   }
95177
95178 }
95179
95180
95181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95182   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95183   std::vector< Dali::Actor > *arg2 = 0 ;
95184
95185   arg1 = (std::vector< Dali::Actor > *)jarg1;
95186   arg2 = (std::vector< Dali::Actor > *)jarg2;
95187   if (!arg2) {
95188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95189     return ;
95190   }
95191   {
95192     try {
95193       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95194     } catch (std::out_of_range& e) {
95195       {
95196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95197       };
95198     } catch (std::exception& e) {
95199       {
95200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95201       };
95202     } catch (Dali::DaliException e) {
95203       {
95204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95205       };
95206     } catch (...) {
95207       {
95208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95209       };
95210     }
95211   }
95212
95213 }
95214
95215
95216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95217   void * jresult ;
95218   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95219   int arg2 ;
95220   int arg3 ;
95221   std::vector< Dali::Actor > *result = 0 ;
95222
95223   arg1 = (std::vector< Dali::Actor > *)jarg1;
95224   arg2 = (int)jarg2;
95225   arg3 = (int)jarg3;
95226   {
95227     try {
95228       try {
95229         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95230       }
95231       catch(std::out_of_range &_e) {
95232         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95233         return 0;
95234       }
95235       catch(std::invalid_argument &_e) {
95236         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95237         return 0;
95238       }
95239
95240     } catch (std::out_of_range& e) {
95241       {
95242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95243       };
95244     } catch (std::exception& e) {
95245       {
95246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95247       };
95248     } catch (Dali::DaliException e) {
95249       {
95250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95251       };
95252     } catch (...) {
95253       {
95254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95255       };
95256     }
95257   }
95258
95259   jresult = (void *)result;
95260   return jresult;
95261 }
95262
95263
95264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95265   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95266   int arg2 ;
95267   Dali::Actor *arg3 = 0 ;
95268
95269   arg1 = (std::vector< Dali::Actor > *)jarg1;
95270   arg2 = (int)jarg2;
95271   arg3 = (Dali::Actor *)jarg3;
95272   if (!arg3) {
95273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95274     return ;
95275   }
95276   {
95277     try {
95278       try {
95279         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95280       }
95281       catch(std::out_of_range &_e) {
95282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95283         return ;
95284       }
95285
95286     } catch (std::out_of_range& e) {
95287       {
95288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95289       };
95290     } catch (std::exception& e) {
95291       {
95292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95293       };
95294     } catch (Dali::DaliException e) {
95295       {
95296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95297       };
95298     } catch (...) {
95299       {
95300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95301       };
95302     }
95303   }
95304
95305 }
95306
95307
95308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95309   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95310   int arg2 ;
95311   std::vector< Dali::Actor > *arg3 = 0 ;
95312
95313   arg1 = (std::vector< Dali::Actor > *)jarg1;
95314   arg2 = (int)jarg2;
95315   arg3 = (std::vector< Dali::Actor > *)jarg3;
95316   if (!arg3) {
95317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95318     return ;
95319   }
95320   {
95321     try {
95322       try {
95323         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95324       }
95325       catch(std::out_of_range &_e) {
95326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95327         return ;
95328       }
95329
95330     } catch (std::out_of_range& e) {
95331       {
95332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95333       };
95334     } catch (std::exception& e) {
95335       {
95336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95337       };
95338     } catch (Dali::DaliException e) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95341       };
95342     } catch (...) {
95343       {
95344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95345       };
95346     }
95347   }
95348
95349 }
95350
95351
95352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95353   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95354   int arg2 ;
95355
95356   arg1 = (std::vector< Dali::Actor > *)jarg1;
95357   arg2 = (int)jarg2;
95358   {
95359     try {
95360       try {
95361         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95362       }
95363       catch(std::out_of_range &_e) {
95364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95365         return ;
95366       }
95367
95368     } catch (std::out_of_range& e) {
95369       {
95370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95371       };
95372     } catch (std::exception& e) {
95373       {
95374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95375       };
95376     } catch (Dali::DaliException e) {
95377       {
95378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95379       };
95380     } catch (...) {
95381       {
95382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95383       };
95384     }
95385   }
95386
95387 }
95388
95389
95390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95391   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95392   int arg2 ;
95393   int arg3 ;
95394
95395   arg1 = (std::vector< Dali::Actor > *)jarg1;
95396   arg2 = (int)jarg2;
95397   arg3 = (int)jarg3;
95398   {
95399     try {
95400       try {
95401         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95402       }
95403       catch(std::out_of_range &_e) {
95404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95405         return ;
95406       }
95407       catch(std::invalid_argument &_e) {
95408         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95409         return ;
95410       }
95411
95412     } catch (std::out_of_range& e) {
95413       {
95414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95415       };
95416     } catch (std::exception& e) {
95417       {
95418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95419       };
95420     } catch (Dali::DaliException e) {
95421       {
95422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95423       };
95424     } catch (...) {
95425       {
95426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95427       };
95428     }
95429   }
95430
95431 }
95432
95433
95434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95435   void * jresult ;
95436   Dali::Actor *arg1 = 0 ;
95437   int arg2 ;
95438   std::vector< Dali::Actor > *result = 0 ;
95439
95440   arg1 = (Dali::Actor *)jarg1;
95441   if (!arg1) {
95442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95443     return 0;
95444   }
95445   arg2 = (int)jarg2;
95446   {
95447     try {
95448       try {
95449         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95450       }
95451       catch(std::out_of_range &_e) {
95452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95453         return 0;
95454       }
95455
95456     } catch (std::out_of_range& e) {
95457       {
95458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95459       };
95460     } catch (std::exception& e) {
95461       {
95462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95463       };
95464     } catch (Dali::DaliException e) {
95465       {
95466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95467       };
95468     } catch (...) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95471       };
95472     }
95473   }
95474
95475   jresult = (void *)result;
95476   return jresult;
95477 }
95478
95479
95480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95481   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95482
95483   arg1 = (std::vector< Dali::Actor > *)jarg1;
95484   {
95485     try {
95486       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95487     } catch (std::out_of_range& e) {
95488       {
95489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95490       };
95491     } catch (std::exception& e) {
95492       {
95493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95494       };
95495     } catch (Dali::DaliException e) {
95496       {
95497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95498       };
95499     } catch (...) {
95500       {
95501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95502       };
95503     }
95504   }
95505
95506 }
95507
95508
95509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95510   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95511   int arg2 ;
95512   int arg3 ;
95513
95514   arg1 = (std::vector< Dali::Actor > *)jarg1;
95515   arg2 = (int)jarg2;
95516   arg3 = (int)jarg3;
95517   {
95518     try {
95519       try {
95520         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95521       }
95522       catch(std::out_of_range &_e) {
95523         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95524         return ;
95525       }
95526       catch(std::invalid_argument &_e) {
95527         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95528         return ;
95529       }
95530
95531     } catch (std::out_of_range& e) {
95532       {
95533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95534       };
95535     } catch (std::exception& e) {
95536       {
95537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95538       };
95539     } catch (Dali::DaliException e) {
95540       {
95541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95542       };
95543     } catch (...) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95546       };
95547     }
95548   }
95549
95550 }
95551
95552
95553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95554   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95555   int arg2 ;
95556   std::vector< Dali::Actor > *arg3 = 0 ;
95557
95558   arg1 = (std::vector< Dali::Actor > *)jarg1;
95559   arg2 = (int)jarg2;
95560   arg3 = (std::vector< Dali::Actor > *)jarg3;
95561   if (!arg3) {
95562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95563     return ;
95564   }
95565   {
95566     try {
95567       try {
95568         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95569       }
95570       catch(std::out_of_range &_e) {
95571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95572         return ;
95573       }
95574
95575     } catch (std::out_of_range& e) {
95576       {
95577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95578       };
95579     } catch (std::exception& e) {
95580       {
95581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95582       };
95583     } catch (Dali::DaliException e) {
95584       {
95585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95586       };
95587     } catch (...) {
95588       {
95589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95590       };
95591     }
95592   }
95593
95594 }
95595
95596
95597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95598   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95599
95600   arg1 = (std::vector< Dali::Actor > *)jarg1;
95601   {
95602     try {
95603       delete arg1;
95604     } catch (std::out_of_range& e) {
95605       {
95606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95607       };
95608     } catch (std::exception& e) {
95609       {
95610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95611       };
95612     } catch (Dali::DaliException e) {
95613       {
95614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95615       };
95616     } catch (...) {
95617       {
95618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95619       };
95620     }
95621   }
95622
95623 }
95624
95625
95626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95627   unsigned int jresult ;
95628   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95629   bool result;
95630
95631   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95632   {
95633     try {
95634       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95635     } catch (std::out_of_range& e) {
95636       {
95637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95638       };
95639     } catch (std::exception& e) {
95640       {
95641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95642       };
95643     } catch (Dali::DaliException e) {
95644       {
95645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95646       };
95647     } catch (...) {
95648       {
95649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95650       };
95651     }
95652   }
95653
95654   jresult = result;
95655   return jresult;
95656 }
95657
95658
95659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95660   unsigned long jresult ;
95661   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95662   std::size_t result;
95663
95664   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95665   {
95666     try {
95667       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95668     } catch (std::out_of_range& e) {
95669       {
95670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95671       };
95672     } catch (std::exception& e) {
95673       {
95674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95675       };
95676     } catch (Dali::DaliException e) {
95677       {
95678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95679       };
95680     } catch (...) {
95681       {
95682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95683       };
95684     }
95685   }
95686
95687   jresult = (unsigned long)result;
95688   return jresult;
95689 }
95690
95691
95692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95693   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95694   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95695
95696   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95697   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95698   {
95699     try {
95700       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95701     } catch (std::out_of_range& e) {
95702       {
95703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95704       };
95705     } catch (std::exception& e) {
95706       {
95707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95708       };
95709     } catch (Dali::DaliException e) {
95710       {
95711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95712       };
95713     } catch (...) {
95714       {
95715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95716       };
95717     }
95718   }
95719
95720 }
95721
95722
95723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95724   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95725   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95726
95727   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95728   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95729   {
95730     try {
95731       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95732     } catch (std::out_of_range& e) {
95733       {
95734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95735       };
95736     } catch (std::exception& e) {
95737       {
95738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95739       };
95740     } catch (Dali::DaliException e) {
95741       {
95742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95743       };
95744     } catch (...) {
95745       {
95746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95747       };
95748     }
95749   }
95750
95751 }
95752
95753
95754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95755   unsigned int jresult ;
95756   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95757   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95758   bool result;
95759
95760   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95761   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95762   if (!arg2) {
95763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95764     return 0;
95765   }
95766   {
95767     try {
95768       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95769     } catch (std::out_of_range& e) {
95770       {
95771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95772       };
95773     } catch (std::exception& e) {
95774       {
95775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95776       };
95777     } catch (Dali::DaliException e) {
95778       {
95779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95780       };
95781     } catch (...) {
95782       {
95783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95784       };
95785     }
95786   }
95787
95788   jresult = result;
95789   return jresult;
95790 }
95791
95792
95793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95794   void * jresult ;
95795   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95796
95797   {
95798     try {
95799       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95800     } catch (std::out_of_range& e) {
95801       {
95802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95803       };
95804     } catch (std::exception& e) {
95805       {
95806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95807       };
95808     } catch (Dali::DaliException e) {
95809       {
95810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95811       };
95812     } catch (...) {
95813       {
95814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95815       };
95816     }
95817   }
95818
95819   jresult = (void *)result;
95820   return jresult;
95821 }
95822
95823
95824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95825   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95826
95827   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95828   {
95829     try {
95830       delete arg1;
95831     } catch (std::out_of_range& e) {
95832       {
95833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95834       };
95835     } catch (std::exception& e) {
95836       {
95837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95838       };
95839     } catch (Dali::DaliException e) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95842       };
95843     } catch (...) {
95844       {
95845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95846       };
95847     }
95848   }
95849
95850 }
95851
95852
95853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95854   unsigned int jresult ;
95855   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95856   bool result;
95857
95858   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95859   {
95860     try {
95861       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);
95862     } catch (std::out_of_range& e) {
95863       {
95864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95865       };
95866     } catch (std::exception& e) {
95867       {
95868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95869       };
95870     } catch (Dali::DaliException e) {
95871       {
95872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95873       };
95874     } catch (...) {
95875       {
95876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95877       };
95878     }
95879   }
95880
95881   jresult = result;
95882   return jresult;
95883 }
95884
95885
95886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95887   unsigned long jresult ;
95888   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95889   std::size_t result;
95890
95891   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95892   {
95893     try {
95894       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);
95895     } catch (std::out_of_range& e) {
95896       {
95897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95898       };
95899     } catch (std::exception& e) {
95900       {
95901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95902       };
95903     } catch (Dali::DaliException e) {
95904       {
95905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95906       };
95907     } catch (...) {
95908       {
95909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95910       };
95911     }
95912   }
95913
95914   jresult = (unsigned long)result;
95915   return jresult;
95916 }
95917
95918
95919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95920   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95921   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95922
95923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95924   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95925   {
95926     try {
95927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95928     } catch (std::out_of_range& e) {
95929       {
95930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95931       };
95932     } catch (std::exception& e) {
95933       {
95934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95935       };
95936     } catch (Dali::DaliException e) {
95937       {
95938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95939       };
95940     } catch (...) {
95941       {
95942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95943       };
95944     }
95945   }
95946
95947 }
95948
95949
95950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95951   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95952   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95953
95954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95955   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95956   {
95957     try {
95958       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95959     } catch (std::out_of_range& e) {
95960       {
95961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (std::exception& e) {
95964       {
95965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95966       };
95967     } catch (Dali::DaliException e) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95970       };
95971     } catch (...) {
95972       {
95973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95974       };
95975     }
95976   }
95977
95978 }
95979
95980
95981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95982   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95983   Dali::Actor arg2 ;
95984   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95985   Dali::Actor *argp2 ;
95986
95987   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95988   argp2 = (Dali::Actor *)jarg2;
95989   if (!argp2) {
95990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95991     return ;
95992   }
95993   arg2 = *argp2;
95994   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95995   {
95996     try {
95997       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95998     } catch (std::out_of_range& e) {
95999       {
96000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (std::exception& e) {
96003       {
96004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96005       };
96006     } catch (Dali::DaliException e) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96009       };
96010     } catch (...) {
96011       {
96012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96013       };
96014     }
96015   }
96016
96017 }
96018
96019
96020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96021   void * jresult ;
96022   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96023
96024   {
96025     try {
96026       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96027     } catch (std::out_of_range& e) {
96028       {
96029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96030       };
96031     } catch (std::exception& e) {
96032       {
96033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96034       };
96035     } catch (Dali::DaliException e) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96038       };
96039     } catch (...) {
96040       {
96041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96042       };
96043     }
96044   }
96045
96046   jresult = (void *)result;
96047   return jresult;
96048 }
96049
96050
96051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96052   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96053
96054   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96055   {
96056     try {
96057       delete arg1;
96058     } catch (std::out_of_range& e) {
96059       {
96060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96061       };
96062     } catch (std::exception& e) {
96063       {
96064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96065       };
96066     } catch (Dali::DaliException e) {
96067       {
96068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96069       };
96070     } catch (...) {
96071       {
96072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96073       };
96074     }
96075   }
96076
96077 }
96078
96079
96080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96081   unsigned int jresult ;
96082   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96083   bool result;
96084
96085   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96086   {
96087     try {
96088       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96089     } catch (std::out_of_range& e) {
96090       {
96091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96092       };
96093     } catch (std::exception& e) {
96094       {
96095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96096       };
96097     } catch (Dali::DaliException e) {
96098       {
96099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96100       };
96101     } catch (...) {
96102       {
96103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96104       };
96105     }
96106   }
96107
96108   jresult = result;
96109   return jresult;
96110 }
96111
96112
96113 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96114   unsigned long jresult ;
96115   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96116   std::size_t result;
96117
96118   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96119   {
96120     try {
96121       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96122     } catch (std::out_of_range& e) {
96123       {
96124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96125       };
96126     } catch (std::exception& e) {
96127       {
96128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96129       };
96130     } catch (Dali::DaliException e) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96133       };
96134     } catch (...) {
96135       {
96136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96137       };
96138     }
96139   }
96140
96141   jresult = (unsigned long)result;
96142   return jresult;
96143 }
96144
96145
96146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96147   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96148   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96149
96150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96151   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96152   {
96153     try {
96154       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96155     } catch (std::out_of_range& e) {
96156       {
96157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96158       };
96159     } catch (std::exception& e) {
96160       {
96161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96162       };
96163     } catch (Dali::DaliException e) {
96164       {
96165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96166       };
96167     } catch (...) {
96168       {
96169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96170       };
96171     }
96172   }
96173
96174 }
96175
96176
96177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96178   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96179   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96180
96181   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96182   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96183   {
96184     try {
96185       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96186     } catch (std::out_of_range& e) {
96187       {
96188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (std::exception& e) {
96191       {
96192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96193       };
96194     } catch (Dali::DaliException e) {
96195       {
96196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96197       };
96198     } catch (...) {
96199       {
96200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96201       };
96202     }
96203   }
96204
96205 }
96206
96207
96208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96209   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96210   Dali::Actor arg2 ;
96211   Dali::Actor arg3 ;
96212   Dali::Actor *argp2 ;
96213   Dali::Actor *argp3 ;
96214
96215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96216   argp2 = (Dali::Actor *)jarg2;
96217   if (!argp2) {
96218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96219     return ;
96220   }
96221   arg2 = *argp2;
96222   argp3 = (Dali::Actor *)jarg3;
96223   if (!argp3) {
96224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96225     return ;
96226   }
96227   arg3 = *argp3;
96228   {
96229     try {
96230       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96231     } catch (std::out_of_range& e) {
96232       {
96233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96234       };
96235     } catch (std::exception& e) {
96236       {
96237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96238       };
96239     } catch (Dali::DaliException e) {
96240       {
96241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96242       };
96243     } catch (...) {
96244       {
96245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96246       };
96247     }
96248   }
96249
96250 }
96251
96252
96253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96254   void * jresult ;
96255   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96256
96257   {
96258     try {
96259       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96260     } catch (std::out_of_range& e) {
96261       {
96262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96263       };
96264     } catch (std::exception& e) {
96265       {
96266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96267       };
96268     } catch (Dali::DaliException e) {
96269       {
96270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96271       };
96272     } catch (...) {
96273       {
96274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96275       };
96276     }
96277   }
96278
96279   jresult = (void *)result;
96280   return jresult;
96281 }
96282
96283
96284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96285   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96286
96287   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96288   {
96289     try {
96290       delete arg1;
96291     } catch (std::out_of_range& e) {
96292       {
96293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96294       };
96295     } catch (std::exception& e) {
96296       {
96297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96298       };
96299     } catch (Dali::DaliException e) {
96300       {
96301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96302       };
96303     } catch (...) {
96304       {
96305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96306       };
96307     }
96308   }
96309
96310 }
96311
96312
96313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96314   unsigned int jresult ;
96315   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96316   bool result;
96317
96318   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96319   {
96320     try {
96321       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96322     } catch (std::out_of_range& e) {
96323       {
96324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96325       };
96326     } catch (std::exception& e) {
96327       {
96328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96329       };
96330     } catch (Dali::DaliException e) {
96331       {
96332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96333       };
96334     } catch (...) {
96335       {
96336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96337       };
96338     }
96339   }
96340
96341   jresult = result;
96342   return jresult;
96343 }
96344
96345
96346 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96347   unsigned long jresult ;
96348   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96349   std::size_t result;
96350
96351   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96352   {
96353     try {
96354       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96355     } catch (std::out_of_range& e) {
96356       {
96357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96358       };
96359     } catch (std::exception& e) {
96360       {
96361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96362       };
96363     } catch (Dali::DaliException e) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96366       };
96367     } catch (...) {
96368       {
96369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96370       };
96371     }
96372   }
96373
96374   jresult = (unsigned long)result;
96375   return jresult;
96376 }
96377
96378
96379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96380   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96381   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96382
96383   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96384   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96385   {
96386     try {
96387       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96388     } catch (std::out_of_range& e) {
96389       {
96390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96391       };
96392     } catch (std::exception& e) {
96393       {
96394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96395       };
96396     } catch (Dali::DaliException e) {
96397       {
96398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96399       };
96400     } catch (...) {
96401       {
96402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96403       };
96404     }
96405   }
96406
96407 }
96408
96409
96410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96411   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96412   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96413
96414   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96415   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96416   {
96417     try {
96418       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96419     } catch (std::out_of_range& e) {
96420       {
96421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96422       };
96423     } catch (std::exception& e) {
96424       {
96425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96426       };
96427     } catch (Dali::DaliException e) {
96428       {
96429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96430       };
96431     } catch (...) {
96432       {
96433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96434       };
96435     }
96436   }
96437
96438 }
96439
96440
96441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96442   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96443   Dali::Actor arg2 ;
96444   bool arg3 ;
96445   Dali::Actor *argp2 ;
96446
96447   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96448   argp2 = (Dali::Actor *)jarg2;
96449   if (!argp2) {
96450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96451     return ;
96452   }
96453   arg2 = *argp2;
96454   arg3 = jarg3 ? true : false;
96455   {
96456     try {
96457       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96458     } catch (std::out_of_range& e) {
96459       {
96460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96461       };
96462     } catch (std::exception& e) {
96463       {
96464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96465       };
96466     } catch (Dali::DaliException e) {
96467       {
96468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96469       };
96470     } catch (...) {
96471       {
96472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96473       };
96474     }
96475   }
96476
96477 }
96478
96479
96480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96481   void * jresult ;
96482   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96483
96484   {
96485     try {
96486       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96487     } catch (std::out_of_range& e) {
96488       {
96489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96490       };
96491     } catch (std::exception& e) {
96492       {
96493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96494       };
96495     } catch (Dali::DaliException e) {
96496       {
96497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96498       };
96499     } catch (...) {
96500       {
96501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96502       };
96503     }
96504   }
96505
96506   jresult = (void *)result;
96507   return jresult;
96508 }
96509
96510
96511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96512   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96513
96514   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96515   {
96516     try {
96517       delete arg1;
96518     } catch (std::out_of_range& e) {
96519       {
96520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96521       };
96522     } catch (std::exception& e) {
96523       {
96524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96525       };
96526     } catch (Dali::DaliException e) {
96527       {
96528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96529       };
96530     } catch (...) {
96531       {
96532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96533       };
96534     }
96535   }
96536
96537 }
96538
96539
96540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96541   unsigned int jresult ;
96542   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96543   bool result;
96544
96545   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96546   {
96547     try {
96548       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);
96549     } catch (std::out_of_range& e) {
96550       {
96551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96552       };
96553     } catch (std::exception& e) {
96554       {
96555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96556       };
96557     } catch (Dali::DaliException e) {
96558       {
96559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96560       };
96561     } catch (...) {
96562       {
96563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96564       };
96565     }
96566   }
96567
96568   jresult = result;
96569   return jresult;
96570 }
96571
96572
96573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96574   unsigned long jresult ;
96575   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96576   std::size_t result;
96577
96578   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96579   {
96580     try {
96581       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);
96582     } catch (std::out_of_range& e) {
96583       {
96584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96585       };
96586     } catch (std::exception& e) {
96587       {
96588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96589       };
96590     } catch (Dali::DaliException e) {
96591       {
96592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96593       };
96594     } catch (...) {
96595       {
96596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96597       };
96598     }
96599   }
96600
96601   jresult = (unsigned long)result;
96602   return jresult;
96603 }
96604
96605
96606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96607   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96608   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96609
96610   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96611   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96612   {
96613     try {
96614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96615     } catch (std::out_of_range& e) {
96616       {
96617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96618       };
96619     } catch (std::exception& e) {
96620       {
96621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96622       };
96623     } catch (Dali::DaliException e) {
96624       {
96625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96626       };
96627     } catch (...) {
96628       {
96629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96630       };
96631     }
96632   }
96633
96634 }
96635
96636
96637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96638   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96639   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96640
96641   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96642   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96643   {
96644     try {
96645       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96646     } catch (std::out_of_range& e) {
96647       {
96648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96649       };
96650     } catch (std::exception& e) {
96651       {
96652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96653       };
96654     } catch (Dali::DaliException e) {
96655       {
96656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96657       };
96658     } catch (...) {
96659       {
96660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96661       };
96662     }
96663   }
96664
96665 }
96666
96667
96668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96669   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96670   Dali::Toolkit::StyleManager arg2 ;
96671   Dali::StyleChange::Type arg3 ;
96672   Dali::Toolkit::StyleManager *argp2 ;
96673
96674   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96675   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96676   if (!argp2) {
96677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96678     return ;
96679   }
96680   arg2 = *argp2;
96681   arg3 = (Dali::StyleChange::Type)jarg3;
96682   {
96683     try {
96684       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96685     } catch (std::out_of_range& e) {
96686       {
96687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96688       };
96689     } catch (std::exception& e) {
96690       {
96691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96692       };
96693     } catch (Dali::DaliException e) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96696       };
96697     } catch (...) {
96698       {
96699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96700       };
96701     }
96702   }
96703
96704 }
96705
96706
96707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96708   void * jresult ;
96709   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96710
96711   {
96712     try {
96713       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96714     } catch (std::out_of_range& e) {
96715       {
96716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96717       };
96718     } catch (std::exception& e) {
96719       {
96720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (Dali::DaliException e) {
96723       {
96724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96725       };
96726     } catch (...) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96729       };
96730     }
96731   }
96732
96733   jresult = (void *)result;
96734   return jresult;
96735 }
96736
96737
96738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96739   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96740
96741   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96742   {
96743     try {
96744       delete arg1;
96745     } catch (std::out_of_range& e) {
96746       {
96747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96748       };
96749     } catch (std::exception& e) {
96750       {
96751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96752       };
96753     } catch (Dali::DaliException e) {
96754       {
96755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96756       };
96757     } catch (...) {
96758       {
96759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96760       };
96761     }
96762   }
96763
96764 }
96765
96766
96767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96768   unsigned int jresult ;
96769   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96770   bool result;
96771
96772   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96773   {
96774     try {
96775       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96776     } catch (std::out_of_range& e) {
96777       {
96778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96779       };
96780     } catch (std::exception& e) {
96781       {
96782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96783       };
96784     } catch (Dali::DaliException e) {
96785       {
96786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96787       };
96788     } catch (...) {
96789       {
96790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96791       };
96792     }
96793   }
96794
96795   jresult = result;
96796   return jresult;
96797 }
96798
96799
96800 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96801   unsigned long jresult ;
96802   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96803   std::size_t result;
96804
96805   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96806   {
96807     try {
96808       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96809     } catch (std::out_of_range& e) {
96810       {
96811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96812       };
96813     } catch (std::exception& e) {
96814       {
96815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96816       };
96817     } catch (Dali::DaliException e) {
96818       {
96819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96820       };
96821     } catch (...) {
96822       {
96823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96824       };
96825     }
96826   }
96827
96828   jresult = (unsigned long)result;
96829   return jresult;
96830 }
96831
96832
96833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96834   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96835   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96836
96837   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96838   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96839   {
96840     try {
96841       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96842     } catch (std::out_of_range& e) {
96843       {
96844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96845       };
96846     } catch (std::exception& e) {
96847       {
96848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96849       };
96850     } catch (Dali::DaliException e) {
96851       {
96852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96853       };
96854     } catch (...) {
96855       {
96856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96857       };
96858     }
96859   }
96860
96861 }
96862
96863
96864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96865   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96866   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96867
96868   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96869   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96870   {
96871     try {
96872       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96873     } catch (std::out_of_range& e) {
96874       {
96875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96876       };
96877     } catch (std::exception& e) {
96878       {
96879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96880       };
96881     } catch (Dali::DaliException e) {
96882       {
96883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96884       };
96885     } catch (...) {
96886       {
96887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96888       };
96889     }
96890   }
96891
96892 }
96893
96894
96895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96896   unsigned int jresult ;
96897   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96898   Dali::Toolkit::Button arg2 ;
96899   Dali::Toolkit::Button *argp2 ;
96900   bool result;
96901
96902   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96903   argp2 = (Dali::Toolkit::Button *)jarg2;
96904   if (!argp2) {
96905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96906     return 0;
96907   }
96908   arg2 = *argp2;
96909   {
96910     try {
96911       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96912     } catch (std::out_of_range& e) {
96913       {
96914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96915       };
96916     } catch (std::exception& e) {
96917       {
96918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96919       };
96920     } catch (Dali::DaliException e) {
96921       {
96922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96923       };
96924     } catch (...) {
96925       {
96926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96927       };
96928     }
96929   }
96930
96931   jresult = result;
96932   return jresult;
96933 }
96934
96935
96936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96937   void * jresult ;
96938   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96939
96940   {
96941     try {
96942       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96943     } catch (std::out_of_range& e) {
96944       {
96945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96946       };
96947     } catch (std::exception& e) {
96948       {
96949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96950       };
96951     } catch (Dali::DaliException e) {
96952       {
96953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96954       };
96955     } catch (...) {
96956       {
96957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96958       };
96959     }
96960   }
96961
96962   jresult = (void *)result;
96963   return jresult;
96964 }
96965
96966
96967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96968   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96969
96970   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96971   {
96972     try {
96973       delete arg1;
96974     } catch (std::out_of_range& e) {
96975       {
96976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96977       };
96978     } catch (std::exception& e) {
96979       {
96980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96981       };
96982     } catch (Dali::DaliException e) {
96983       {
96984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96985       };
96986     } catch (...) {
96987       {
96988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96989       };
96990     }
96991   }
96992
96993 }
96994
96995
96996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96997   unsigned int jresult ;
96998   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96999   bool result;
97000
97001   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97002   {
97003     try {
97004       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97005     } catch (std::out_of_range& e) {
97006       {
97007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97008       };
97009     } catch (std::exception& e) {
97010       {
97011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97012       };
97013     } catch (Dali::DaliException e) {
97014       {
97015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97016       };
97017     } catch (...) {
97018       {
97019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97020       };
97021     }
97022   }
97023
97024   jresult = result;
97025   return jresult;
97026 }
97027
97028
97029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97030   unsigned long jresult ;
97031   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97032   std::size_t result;
97033
97034   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97035   {
97036     try {
97037       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97038     } catch (std::out_of_range& e) {
97039       {
97040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97041       };
97042     } catch (std::exception& e) {
97043       {
97044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97045       };
97046     } catch (Dali::DaliException e) {
97047       {
97048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97049       };
97050     } catch (...) {
97051       {
97052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97053       };
97054     }
97055   }
97056
97057   jresult = (unsigned long)result;
97058   return jresult;
97059 }
97060
97061
97062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97063   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97064   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97065
97066   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97067   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97068   {
97069     try {
97070       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97071     } catch (std::out_of_range& e) {
97072       {
97073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97074       };
97075     } catch (std::exception& e) {
97076       {
97077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97078       };
97079     } catch (Dali::DaliException e) {
97080       {
97081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97082       };
97083     } catch (...) {
97084       {
97085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97086       };
97087     }
97088   }
97089
97090 }
97091
97092
97093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97094   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97095   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97096
97097   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97098   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97099   {
97100     try {
97101       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97102     } catch (std::out_of_range& e) {
97103       {
97104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97105       };
97106     } catch (std::exception& e) {
97107       {
97108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97109       };
97110     } catch (Dali::DaliException e) {
97111       {
97112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97113       };
97114     } catch (...) {
97115       {
97116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97117       };
97118     }
97119   }
97120
97121 }
97122
97123
97124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97125   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97126   Dali::Toolkit::GaussianBlurView arg2 ;
97127   Dali::Toolkit::GaussianBlurView *argp2 ;
97128
97129   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97130   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97131   if (!argp2) {
97132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97133     return ;
97134   }
97135   arg2 = *argp2;
97136   {
97137     try {
97138       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97139     } catch (std::out_of_range& e) {
97140       {
97141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97142       };
97143     } catch (std::exception& e) {
97144       {
97145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97146       };
97147     } catch (Dali::DaliException e) {
97148       {
97149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97150       };
97151     } catch (...) {
97152       {
97153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97154       };
97155     }
97156   }
97157
97158 }
97159
97160
97161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97162   void * jresult ;
97163   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97164
97165   {
97166     try {
97167       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97168     } catch (std::out_of_range& e) {
97169       {
97170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97171       };
97172     } catch (std::exception& e) {
97173       {
97174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97175       };
97176     } catch (Dali::DaliException e) {
97177       {
97178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97179       };
97180     } catch (...) {
97181       {
97182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97183       };
97184     }
97185   }
97186
97187   jresult = (void *)result;
97188   return jresult;
97189 }
97190
97191
97192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97193   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97194
97195   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97196   {
97197     try {
97198       delete arg1;
97199     } catch (std::out_of_range& e) {
97200       {
97201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97202       };
97203     } catch (std::exception& e) {
97204       {
97205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97206       };
97207     } catch (Dali::DaliException e) {
97208       {
97209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97210       };
97211     } catch (...) {
97212       {
97213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97214       };
97215     }
97216   }
97217
97218 }
97219
97220
97221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97222   unsigned int jresult ;
97223   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97224   bool result;
97225
97226   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97227   {
97228     try {
97229       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);
97230     } catch (std::out_of_range& e) {
97231       {
97232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97233       };
97234     } catch (std::exception& e) {
97235       {
97236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97237       };
97238     } catch (Dali::DaliException e) {
97239       {
97240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97241       };
97242     } catch (...) {
97243       {
97244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97245       };
97246     }
97247   }
97248
97249   jresult = result;
97250   return jresult;
97251 }
97252
97253
97254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97255   unsigned long jresult ;
97256   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97257   std::size_t result;
97258
97259   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97260   {
97261     try {
97262       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);
97263     } catch (std::out_of_range& e) {
97264       {
97265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97266       };
97267     } catch (std::exception& e) {
97268       {
97269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97270       };
97271     } catch (Dali::DaliException e) {
97272       {
97273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97274       };
97275     } catch (...) {
97276       {
97277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97278       };
97279     }
97280   }
97281
97282   jresult = (unsigned long)result;
97283   return jresult;
97284 }
97285
97286
97287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97288   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97289   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97290
97291   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97292   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97293   {
97294     try {
97295       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97296     } catch (std::out_of_range& e) {
97297       {
97298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97299       };
97300     } catch (std::exception& e) {
97301       {
97302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97303       };
97304     } catch (Dali::DaliException e) {
97305       {
97306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97307       };
97308     } catch (...) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97311       };
97312     }
97313   }
97314
97315 }
97316
97317
97318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97319   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97320   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97321
97322   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97323   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97324   {
97325     try {
97326       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97327     } catch (std::out_of_range& e) {
97328       {
97329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97330       };
97331     } catch (std::exception& e) {
97332       {
97333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97334       };
97335     } catch (Dali::DaliException e) {
97336       {
97337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97338       };
97339     } catch (...) {
97340       {
97341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97342       };
97343     }
97344   }
97345
97346 }
97347
97348
97349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97350   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97351   Dali::Toolkit::PageTurnView arg2 ;
97352   unsigned int arg3 ;
97353   bool arg4 ;
97354   Dali::Toolkit::PageTurnView *argp2 ;
97355
97356   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97357   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97358   if (!argp2) {
97359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97360     return ;
97361   }
97362   arg2 = *argp2;
97363   arg3 = (unsigned int)jarg3;
97364   arg4 = jarg4 ? true : false;
97365   {
97366     try {
97367       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97368     } catch (std::out_of_range& e) {
97369       {
97370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97371       };
97372     } catch (std::exception& e) {
97373       {
97374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97375       };
97376     } catch (Dali::DaliException e) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97379       };
97380     } catch (...) {
97381       {
97382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97383       };
97384     }
97385   }
97386
97387 }
97388
97389
97390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97391   void * jresult ;
97392   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97393
97394   {
97395     try {
97396       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97397     } catch (std::out_of_range& e) {
97398       {
97399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97400       };
97401     } catch (std::exception& e) {
97402       {
97403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97404       };
97405     } catch (Dali::DaliException e) {
97406       {
97407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97408       };
97409     } catch (...) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97412       };
97413     }
97414   }
97415
97416   jresult = (void *)result;
97417   return jresult;
97418 }
97419
97420
97421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97422   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97423
97424   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97425   {
97426     try {
97427       delete arg1;
97428     } catch (std::out_of_range& e) {
97429       {
97430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97431       };
97432     } catch (std::exception& e) {
97433       {
97434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97435       };
97436     } catch (Dali::DaliException e) {
97437       {
97438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97439       };
97440     } catch (...) {
97441       {
97442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97443       };
97444     }
97445   }
97446
97447 }
97448
97449
97450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97451   unsigned int jresult ;
97452   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97453   bool result;
97454
97455   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97456   {
97457     try {
97458       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97459     } catch (std::out_of_range& e) {
97460       {
97461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97462       };
97463     } catch (std::exception& e) {
97464       {
97465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97466       };
97467     } catch (Dali::DaliException e) {
97468       {
97469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97470       };
97471     } catch (...) {
97472       {
97473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97474       };
97475     }
97476   }
97477
97478   jresult = result;
97479   return jresult;
97480 }
97481
97482
97483 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97484   unsigned long jresult ;
97485   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97486   std::size_t result;
97487
97488   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97489   {
97490     try {
97491       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97492     } catch (std::out_of_range& e) {
97493       {
97494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97495       };
97496     } catch (std::exception& e) {
97497       {
97498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97499       };
97500     } catch (Dali::DaliException e) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97503       };
97504     } catch (...) {
97505       {
97506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97507       };
97508     }
97509   }
97510
97511   jresult = (unsigned long)result;
97512   return jresult;
97513 }
97514
97515
97516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97517   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97518   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97519
97520   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97521   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97522   {
97523     try {
97524       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97525     } catch (std::out_of_range& e) {
97526       {
97527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97528       };
97529     } catch (std::exception& e) {
97530       {
97531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97532       };
97533     } catch (Dali::DaliException e) {
97534       {
97535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97536       };
97537     } catch (...) {
97538       {
97539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97540       };
97541     }
97542   }
97543
97544 }
97545
97546
97547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97548   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97549   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97550
97551   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97552   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97553   {
97554     try {
97555       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97556     } catch (std::out_of_range& e) {
97557       {
97558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97559       };
97560     } catch (std::exception& e) {
97561       {
97562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97563       };
97564     } catch (Dali::DaliException e) {
97565       {
97566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97567       };
97568     } catch (...) {
97569       {
97570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97571       };
97572     }
97573   }
97574
97575 }
97576
97577
97578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97579   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97580   Dali::Toolkit::PageTurnView arg2 ;
97581   Dali::Toolkit::PageTurnView *argp2 ;
97582
97583   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97584   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97585   if (!argp2) {
97586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97587     return ;
97588   }
97589   arg2 = *argp2;
97590   {
97591     try {
97592       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97593     } catch (std::out_of_range& e) {
97594       {
97595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97596       };
97597     } catch (std::exception& e) {
97598       {
97599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97600       };
97601     } catch (Dali::DaliException e) {
97602       {
97603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97604       };
97605     } catch (...) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97608       };
97609     }
97610   }
97611
97612 }
97613
97614
97615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97616   void * jresult ;
97617   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97618
97619   {
97620     try {
97621       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97622     } catch (std::out_of_range& e) {
97623       {
97624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97625       };
97626     } catch (std::exception& e) {
97627       {
97628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97629       };
97630     } catch (Dali::DaliException e) {
97631       {
97632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97633       };
97634     } catch (...) {
97635       {
97636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97637       };
97638     }
97639   }
97640
97641   jresult = (void *)result;
97642   return jresult;
97643 }
97644
97645
97646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97647   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97648
97649   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97650   {
97651     try {
97652       delete arg1;
97653     } catch (std::out_of_range& e) {
97654       {
97655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97656       };
97657     } catch (std::exception& e) {
97658       {
97659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97660       };
97661     } catch (Dali::DaliException e) {
97662       {
97663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97664       };
97665     } catch (...) {
97666       {
97667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97668       };
97669     }
97670   }
97671
97672 }
97673
97674
97675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97676   unsigned int jresult ;
97677   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97678   bool result;
97679
97680   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97681   {
97682     try {
97683       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);
97684     } catch (std::out_of_range& e) {
97685       {
97686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97687       };
97688     } catch (std::exception& e) {
97689       {
97690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97691       };
97692     } catch (Dali::DaliException e) {
97693       {
97694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97695       };
97696     } catch (...) {
97697       {
97698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97699       };
97700     }
97701   }
97702
97703   jresult = result;
97704   return jresult;
97705 }
97706
97707
97708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97709   unsigned long jresult ;
97710   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97711   std::size_t result;
97712
97713   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97714   {
97715     try {
97716       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);
97717     } catch (std::out_of_range& e) {
97718       {
97719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97720       };
97721     } catch (std::exception& e) {
97722       {
97723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97724       };
97725     } catch (Dali::DaliException e) {
97726       {
97727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97728       };
97729     } catch (...) {
97730       {
97731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97732       };
97733     }
97734   }
97735
97736   jresult = (unsigned long)result;
97737   return jresult;
97738 }
97739
97740
97741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97742   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97743   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97744
97745   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97746   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97747   {
97748     try {
97749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97750     } catch (std::out_of_range& e) {
97751       {
97752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97753       };
97754     } catch (std::exception& e) {
97755       {
97756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97757       };
97758     } catch (Dali::DaliException e) {
97759       {
97760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97761       };
97762     } catch (...) {
97763       {
97764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97765       };
97766     }
97767   }
97768
97769 }
97770
97771
97772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97773   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97774   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97775
97776   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97777   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97778   {
97779     try {
97780       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97781     } catch (std::out_of_range& e) {
97782       {
97783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97784       };
97785     } catch (std::exception& e) {
97786       {
97787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97788       };
97789     } catch (Dali::DaliException e) {
97790       {
97791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97792       };
97793     } catch (...) {
97794       {
97795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97796       };
97797     }
97798   }
97799
97800 }
97801
97802
97803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97804   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97805   Dali::Toolkit::ProgressBar arg2 ;
97806   float arg3 ;
97807   float arg4 ;
97808   Dali::Toolkit::ProgressBar *argp2 ;
97809
97810   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97811   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97812   if (!argp2) {
97813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97814     return ;
97815   }
97816   arg2 = *argp2;
97817   arg3 = (float)jarg3;
97818   arg4 = (float)jarg4;
97819   {
97820     try {
97821       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97822     } catch (std::out_of_range& e) {
97823       {
97824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97825       };
97826     } catch (std::exception& e) {
97827       {
97828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97829       };
97830     } catch (Dali::DaliException e) {
97831       {
97832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97833       };
97834     } catch (...) {
97835       {
97836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97837       };
97838     }
97839   }
97840
97841 }
97842
97843
97844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97845   void * jresult ;
97846   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97847
97848   {
97849     try {
97850       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97851     } catch (std::out_of_range& e) {
97852       {
97853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97854       };
97855     } catch (std::exception& e) {
97856       {
97857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97858       };
97859     } catch (Dali::DaliException e) {
97860       {
97861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97862       };
97863     } catch (...) {
97864       {
97865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97866       };
97867     }
97868   }
97869
97870   jresult = (void *)result;
97871   return jresult;
97872 }
97873
97874
97875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97876   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97877
97878   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97879   {
97880     try {
97881       delete arg1;
97882     } catch (std::out_of_range& e) {
97883       {
97884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97885       };
97886     } catch (std::exception& e) {
97887       {
97888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97889       };
97890     } catch (Dali::DaliException e) {
97891       {
97892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97893       };
97894     } catch (...) {
97895       {
97896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97897       };
97898     }
97899   }
97900
97901 }
97902
97903
97904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97905   unsigned int jresult ;
97906   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97907   bool result;
97908
97909   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97910   {
97911     try {
97912       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);
97913     } catch (std::out_of_range& e) {
97914       {
97915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97916       };
97917     } catch (std::exception& e) {
97918       {
97919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97920       };
97921     } catch (Dali::DaliException e) {
97922       {
97923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97924       };
97925     } catch (...) {
97926       {
97927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97928       };
97929     }
97930   }
97931
97932   jresult = result;
97933   return jresult;
97934 }
97935
97936
97937 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97938   unsigned long jresult ;
97939   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97940   std::size_t result;
97941
97942   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97943   {
97944     try {
97945       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);
97946     } catch (std::out_of_range& e) {
97947       {
97948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97949       };
97950     } catch (std::exception& e) {
97951       {
97952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97953       };
97954     } catch (Dali::DaliException e) {
97955       {
97956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97957       };
97958     } catch (...) {
97959       {
97960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97961       };
97962     }
97963   }
97964
97965   jresult = (unsigned long)result;
97966   return jresult;
97967 }
97968
97969
97970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97971   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97972   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97973
97974   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97975   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97976   {
97977     try {
97978       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97979     } catch (std::out_of_range& e) {
97980       {
97981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97982       };
97983     } catch (std::exception& e) {
97984       {
97985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97986       };
97987     } catch (Dali::DaliException e) {
97988       {
97989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97990       };
97991     } catch (...) {
97992       {
97993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97994       };
97995     }
97996   }
97997
97998 }
97999
98000
98001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98002   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98003   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98004
98005   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98006   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98007   {
98008     try {
98009       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98010     } catch (std::out_of_range& e) {
98011       {
98012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98013       };
98014     } catch (std::exception& e) {
98015       {
98016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98017       };
98018     } catch (Dali::DaliException e) {
98019       {
98020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98021       };
98022     } catch (...) {
98023       {
98024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98025       };
98026     }
98027   }
98028
98029 }
98030
98031
98032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98033   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98034   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98035
98036   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98037   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98038   if (!arg2) {
98039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98040     return ;
98041   }
98042   {
98043     try {
98044       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98045     } catch (std::out_of_range& e) {
98046       {
98047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98048       };
98049     } catch (std::exception& e) {
98050       {
98051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98052       };
98053     } catch (Dali::DaliException e) {
98054       {
98055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98056       };
98057     } catch (...) {
98058       {
98059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98060       };
98061     }
98062   }
98063
98064 }
98065
98066
98067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98068   void * jresult ;
98069   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98070
98071   {
98072     try {
98073       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98074     } catch (std::out_of_range& e) {
98075       {
98076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98077       };
98078     } catch (std::exception& e) {
98079       {
98080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98081       };
98082     } catch (Dali::DaliException e) {
98083       {
98084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98085       };
98086     } catch (...) {
98087       {
98088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98089       };
98090     }
98091   }
98092
98093   jresult = (void *)result;
98094   return jresult;
98095 }
98096
98097
98098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98099   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98100
98101   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98102   {
98103     try {
98104       delete arg1;
98105     } catch (std::out_of_range& e) {
98106       {
98107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98108       };
98109     } catch (std::exception& e) {
98110       {
98111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98112       };
98113     } catch (Dali::DaliException e) {
98114       {
98115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98116       };
98117     } catch (...) {
98118       {
98119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98120       };
98121     }
98122   }
98123
98124 }
98125
98126
98127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98128   unsigned int jresult ;
98129   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98130   bool result;
98131
98132   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98133   {
98134     try {
98135       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98136     } catch (std::out_of_range& e) {
98137       {
98138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98139       };
98140     } catch (std::exception& e) {
98141       {
98142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98143       };
98144     } catch (Dali::DaliException e) {
98145       {
98146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98147       };
98148     } catch (...) {
98149       {
98150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98151       };
98152     }
98153   }
98154
98155   jresult = result;
98156   return jresult;
98157 }
98158
98159
98160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98161   unsigned long jresult ;
98162   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98163   std::size_t result;
98164
98165   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98166   {
98167     try {
98168       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98169     } catch (std::out_of_range& e) {
98170       {
98171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98172       };
98173     } catch (std::exception& e) {
98174       {
98175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98176       };
98177     } catch (Dali::DaliException e) {
98178       {
98179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98180       };
98181     } catch (...) {
98182       {
98183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98184       };
98185     }
98186   }
98187
98188   jresult = (unsigned long)result;
98189   return jresult;
98190 }
98191
98192
98193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98194   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98195   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98196
98197   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98198   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98199   {
98200     try {
98201       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98202     } catch (std::out_of_range& e) {
98203       {
98204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98205       };
98206     } catch (std::exception& e) {
98207       {
98208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98209       };
98210     } catch (Dali::DaliException e) {
98211       {
98212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98213       };
98214     } catch (...) {
98215       {
98216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98217       };
98218     }
98219   }
98220
98221 }
98222
98223
98224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98225   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98226   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98227
98228   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98229   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98230   {
98231     try {
98232       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98233     } catch (std::out_of_range& e) {
98234       {
98235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98236       };
98237     } catch (std::exception& e) {
98238       {
98239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98240       };
98241     } catch (Dali::DaliException e) {
98242       {
98243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98244       };
98245     } catch (...) {
98246       {
98247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98248       };
98249     }
98250   }
98251
98252 }
98253
98254
98255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98256   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98257   Dali::Vector2 *arg2 = 0 ;
98258
98259   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98260   arg2 = (Dali::Vector2 *)jarg2;
98261   if (!arg2) {
98262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98263     return ;
98264   }
98265   {
98266     try {
98267       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98268     } catch (std::out_of_range& e) {
98269       {
98270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98271       };
98272     } catch (std::exception& e) {
98273       {
98274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98275       };
98276     } catch (Dali::DaliException e) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98279       };
98280     } catch (...) {
98281       {
98282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98283       };
98284     }
98285   }
98286
98287 }
98288
98289
98290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98291   void * jresult ;
98292   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98293
98294   {
98295     try {
98296       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98297     } catch (std::out_of_range& e) {
98298       {
98299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98300       };
98301     } catch (std::exception& e) {
98302       {
98303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98304       };
98305     } catch (Dali::DaliException e) {
98306       {
98307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98308       };
98309     } catch (...) {
98310       {
98311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98312       };
98313     }
98314   }
98315
98316   jresult = (void *)result;
98317   return jresult;
98318 }
98319
98320
98321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98322   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98323
98324   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98325   {
98326     try {
98327       delete arg1;
98328     } catch (std::out_of_range& e) {
98329       {
98330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98331       };
98332     } catch (std::exception& e) {
98333       {
98334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98335       };
98336     } catch (Dali::DaliException e) {
98337       {
98338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98339       };
98340     } catch (...) {
98341       {
98342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98343       };
98344     }
98345   }
98346
98347 }
98348
98349
98350
98351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98352   unsigned int jresult ;
98353   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98354   bool result;
98355
98356   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98357   {
98358     try {
98359       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);
98360     } catch (std::out_of_range& e) {
98361       {
98362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98363       };
98364     } catch (std::exception& e) {
98365       {
98366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98367       };
98368     } catch (Dali::DaliException e) {
98369       {
98370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98371       };
98372     } catch (...) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98375       };
98376     }
98377   }
98378
98379   jresult = result;
98380   return jresult;
98381 }
98382
98383
98384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98385   unsigned long jresult ;
98386   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98387   std::size_t result;
98388
98389   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98390   {
98391     try {
98392       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);
98393     } catch (std::out_of_range& e) {
98394       {
98395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98396       };
98397     } catch (std::exception& e) {
98398       {
98399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98400       };
98401     } catch (Dali::DaliException e) {
98402       {
98403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98404       };
98405     } catch (...) {
98406       {
98407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98408       };
98409     }
98410   }
98411
98412   jresult = (unsigned long)result;
98413   return jresult;
98414 }
98415
98416
98417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98418   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98419   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98420
98421   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98422   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98423   {
98424     try {
98425       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98426     } catch (std::out_of_range& e) {
98427       {
98428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98429       };
98430     } catch (std::exception& e) {
98431       {
98432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98433       };
98434     } catch (Dali::DaliException e) {
98435       {
98436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98437       };
98438     } catch (...) {
98439       {
98440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98441       };
98442     }
98443   }
98444
98445 }
98446
98447
98448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98449   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98450   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98451
98452   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98453   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98454   {
98455     try {
98456       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98457     } catch (std::out_of_range& e) {
98458       {
98459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98460       };
98461     } catch (std::exception& e) {
98462       {
98463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98464       };
98465     } catch (Dali::DaliException e) {
98466       {
98467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98468       };
98469     } catch (...) {
98470       {
98471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98472       };
98473     }
98474   }
98475
98476 }
98477
98478
98479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98480   unsigned int jresult ;
98481   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98482   Dali::Toolkit::Control arg2 ;
98483   Dali::KeyEvent *arg3 = 0 ;
98484   Dali::Toolkit::Control *argp2 ;
98485   bool result;
98486
98487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98488   argp2 = (Dali::Toolkit::Control *)jarg2;
98489   if (!argp2) {
98490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98491     return 0;
98492   }
98493   arg2 = *argp2;
98494   arg3 = (Dali::KeyEvent *)jarg3;
98495   if (!arg3) {
98496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98497     return 0;
98498   }
98499   {
98500     try {
98501       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);
98502     } catch (std::out_of_range& e) {
98503       {
98504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98505       };
98506     } catch (std::exception& e) {
98507       {
98508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98509       };
98510     } catch (Dali::DaliException e) {
98511       {
98512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98513       };
98514     } catch (...) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98517       };
98518     }
98519   }
98520
98521   jresult = result;
98522   return jresult;
98523 }
98524
98525
98526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98527   void * jresult ;
98528   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98529
98530   {
98531     try {
98532       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98533     } catch (std::out_of_range& e) {
98534       {
98535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98536       };
98537     } catch (std::exception& e) {
98538       {
98539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98540       };
98541     } catch (Dali::DaliException e) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98544       };
98545     } catch (...) {
98546       {
98547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98548       };
98549     }
98550   }
98551
98552   jresult = (void *)result;
98553   return jresult;
98554 }
98555
98556
98557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98558   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98559
98560   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98561   {
98562     try {
98563       delete arg1;
98564     } catch (std::out_of_range& e) {
98565       {
98566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98567       };
98568     } catch (std::exception& e) {
98569       {
98570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98571       };
98572     } catch (Dali::DaliException e) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98575       };
98576     } catch (...) {
98577       {
98578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98579       };
98580     }
98581   }
98582
98583 }
98584
98585
98586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98587   unsigned int jresult ;
98588   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98589   bool result;
98590
98591   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98592   {
98593     try {
98594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98595     } catch (std::out_of_range& e) {
98596       {
98597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98598       };
98599     } catch (std::exception& e) {
98600       {
98601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98602       };
98603     } catch (Dali::DaliException e) {
98604       {
98605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98606       };
98607     } catch (...) {
98608       {
98609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98610       };
98611     }
98612   }
98613
98614   jresult = result;
98615   return jresult;
98616 }
98617
98618
98619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98620   unsigned long jresult ;
98621   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98622   std::size_t result;
98623
98624   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98625   {
98626     try {
98627       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98628     } catch (std::out_of_range& e) {
98629       {
98630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98631       };
98632     } catch (std::exception& e) {
98633       {
98634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98635       };
98636     } catch (Dali::DaliException e) {
98637       {
98638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98639       };
98640     } catch (...) {
98641       {
98642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98643       };
98644     }
98645   }
98646
98647   jresult = (unsigned long)result;
98648   return jresult;
98649 }
98650
98651
98652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98653   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98654   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98655
98656   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98657   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98658   {
98659     try {
98660       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98661     } catch (std::out_of_range& e) {
98662       {
98663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98664       };
98665     } catch (std::exception& e) {
98666       {
98667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98668       };
98669     } catch (Dali::DaliException e) {
98670       {
98671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98672       };
98673     } catch (...) {
98674       {
98675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98676       };
98677     }
98678   }
98679
98680 }
98681
98682
98683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98684   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98685   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98686
98687   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98688   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98689   {
98690     try {
98691       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98692     } catch (std::out_of_range& e) {
98693       {
98694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98695       };
98696     } catch (std::exception& e) {
98697       {
98698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98699       };
98700     } catch (Dali::DaliException e) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98703       };
98704     } catch (...) {
98705       {
98706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98707       };
98708     }
98709   }
98710
98711 }
98712
98713
98714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98715   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98716   Dali::Toolkit::Control arg2 ;
98717   Dali::Toolkit::Control *argp2 ;
98718
98719   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98720   argp2 = (Dali::Toolkit::Control *)jarg2;
98721   if (!argp2) {
98722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98723     return ;
98724   }
98725   arg2 = *argp2;
98726   {
98727     try {
98728       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98729     } catch (std::out_of_range& e) {
98730       {
98731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98732       };
98733     } catch (std::exception& e) {
98734       {
98735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98736       };
98737     } catch (Dali::DaliException e) {
98738       {
98739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98740       };
98741     } catch (...) {
98742       {
98743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98744       };
98745     }
98746   }
98747
98748 }
98749
98750
98751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98752   void * jresult ;
98753   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98754
98755   {
98756     try {
98757       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98758     } catch (std::out_of_range& e) {
98759       {
98760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98761       };
98762     } catch (std::exception& e) {
98763       {
98764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98765       };
98766     } catch (Dali::DaliException e) {
98767       {
98768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98769       };
98770     } catch (...) {
98771       {
98772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98773       };
98774     }
98775   }
98776
98777   jresult = (void *)result;
98778   return jresult;
98779 }
98780
98781
98782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98783   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98784
98785   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98786   {
98787     try {
98788       delete arg1;
98789     } catch (std::out_of_range& e) {
98790       {
98791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98792       };
98793     } catch (std::exception& e) {
98794       {
98795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98796       };
98797     } catch (Dali::DaliException e) {
98798       {
98799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98800       };
98801     } catch (...) {
98802       {
98803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98804       };
98805     }
98806   }
98807
98808 }
98809
98810
98811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98812   unsigned int jresult ;
98813   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98814   bool result;
98815
98816   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98817   {
98818     try {
98819       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98820     } catch (std::out_of_range& e) {
98821       {
98822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98823       };
98824     } catch (std::exception& e) {
98825       {
98826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98827       };
98828     } catch (Dali::DaliException e) {
98829       {
98830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98831       };
98832     } catch (...) {
98833       {
98834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98835       };
98836     }
98837   }
98838
98839   jresult = result;
98840   return jresult;
98841 }
98842
98843
98844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98845   unsigned long jresult ;
98846   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98847   std::size_t result;
98848
98849   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98850   {
98851     try {
98852       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98853     } catch (std::out_of_range& e) {
98854       {
98855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98856       };
98857     } catch (std::exception& e) {
98858       {
98859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98860       };
98861     } catch (Dali::DaliException e) {
98862       {
98863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98864       };
98865     } catch (...) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98868       };
98869     }
98870   }
98871
98872   jresult = (unsigned long)result;
98873   return jresult;
98874 }
98875
98876
98877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98878   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98879   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98880
98881   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98882   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98883   {
98884     try {
98885       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98886     } catch (std::out_of_range& e) {
98887       {
98888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98889       };
98890     } catch (std::exception& e) {
98891       {
98892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98893       };
98894     } catch (Dali::DaliException e) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98897       };
98898     } catch (...) {
98899       {
98900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98901       };
98902     }
98903   }
98904
98905 }
98906
98907
98908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98909   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98910   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98911
98912   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98913   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98914   {
98915     try {
98916       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98917     } catch (std::out_of_range& e) {
98918       {
98919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98920       };
98921     } catch (std::exception& e) {
98922       {
98923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98924       };
98925     } catch (Dali::DaliException e) {
98926       {
98927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98928       };
98929     } catch (...) {
98930       {
98931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98932       };
98933     }
98934   }
98935
98936 }
98937
98938
98939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98940   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98941   Dali::Toolkit::VideoView *arg2 = 0 ;
98942
98943   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98944   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98945   if (!arg2) {
98946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98947     return ;
98948   }
98949   {
98950     try {
98951       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98952     } catch (std::out_of_range& e) {
98953       {
98954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98955       };
98956     } catch (std::exception& e) {
98957       {
98958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98959       };
98960     } catch (Dali::DaliException e) {
98961       {
98962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98963       };
98964     } catch (...) {
98965       {
98966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98967       };
98968     }
98969   }
98970
98971 }
98972
98973
98974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98975   void * jresult ;
98976   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98977
98978   {
98979     try {
98980       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98981     } catch (std::out_of_range& e) {
98982       {
98983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98984       };
98985     } catch (std::exception& e) {
98986       {
98987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98988       };
98989     } catch (Dali::DaliException e) {
98990       {
98991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98992       };
98993     } catch (...) {
98994       {
98995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98996       };
98997     }
98998   }
98999
99000   jresult = (void *)result;
99001   return jresult;
99002 }
99003
99004
99005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99006   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99007
99008   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99009   {
99010     try {
99011       delete arg1;
99012     } catch (std::out_of_range& e) {
99013       {
99014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99015       };
99016     } catch (std::exception& e) {
99017       {
99018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99019       };
99020     } catch (Dali::DaliException e) {
99021       {
99022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99023       };
99024     } catch (...) {
99025       {
99026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99027       };
99028     }
99029   }
99030
99031 }
99032
99033
99034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99035   unsigned int jresult ;
99036   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99037   bool result;
99038
99039   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99040   {
99041     try {
99042       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99043     } catch (std::out_of_range& e) {
99044       {
99045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99046       };
99047     } catch (std::exception& e) {
99048       {
99049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99050       };
99051     } catch (Dali::DaliException e) {
99052       {
99053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99054       };
99055     } catch (...) {
99056       {
99057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99058       };
99059     }
99060   }
99061
99062   jresult = result;
99063   return jresult;
99064 }
99065
99066
99067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99068   unsigned long jresult ;
99069   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99070   std::size_t result;
99071
99072   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99073   {
99074     try {
99075       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99076     } catch (std::out_of_range& e) {
99077       {
99078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99079       };
99080     } catch (std::exception& e) {
99081       {
99082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99083       };
99084     } catch (Dali::DaliException e) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99087       };
99088     } catch (...) {
99089       {
99090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99091       };
99092     }
99093   }
99094
99095   jresult = (unsigned long)result;
99096   return jresult;
99097 }
99098
99099
99100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99101   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99102   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99103
99104   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99105   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99106   {
99107     try {
99108       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99109     } catch (std::out_of_range& e) {
99110       {
99111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99112       };
99113     } catch (std::exception& e) {
99114       {
99115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99116       };
99117     } catch (Dali::DaliException e) {
99118       {
99119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99120       };
99121     } catch (...) {
99122       {
99123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99124       };
99125     }
99126   }
99127
99128 }
99129
99130
99131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99132   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99133   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99134
99135   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99136   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99137   {
99138     try {
99139       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99140     } catch (std::out_of_range& e) {
99141       {
99142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99143       };
99144     } catch (std::exception& e) {
99145       {
99146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99147       };
99148     } catch (Dali::DaliException e) {
99149       {
99150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99151       };
99152     } catch (...) {
99153       {
99154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99155       };
99156     }
99157   }
99158
99159 }
99160
99161
99162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99163   unsigned int jresult ;
99164   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99165   Dali::Toolkit::Slider arg2 ;
99166   float arg3 ;
99167   Dali::Toolkit::Slider *argp2 ;
99168   bool result;
99169
99170   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99171   argp2 = (Dali::Toolkit::Slider *)jarg2;
99172   if (!argp2) {
99173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99174     return 0;
99175   }
99176   arg2 = *argp2;
99177   arg3 = (float)jarg3;
99178   {
99179     try {
99180       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99181     } catch (std::out_of_range& e) {
99182       {
99183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99184       };
99185     } catch (std::exception& e) {
99186       {
99187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99188       };
99189     } catch (Dali::DaliException e) {
99190       {
99191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99192       };
99193     } catch (...) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99196       };
99197     }
99198   }
99199
99200   jresult = result;
99201   return jresult;
99202 }
99203
99204
99205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99206   void * jresult ;
99207   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99208
99209   {
99210     try {
99211       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99212     } catch (std::out_of_range& e) {
99213       {
99214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99215       };
99216     } catch (std::exception& e) {
99217       {
99218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99219       };
99220     } catch (Dali::DaliException e) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99223       };
99224     } catch (...) {
99225       {
99226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99227       };
99228     }
99229   }
99230
99231   jresult = (void *)result;
99232   return jresult;
99233 }
99234
99235
99236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99237   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99238
99239   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99240   {
99241     try {
99242       delete arg1;
99243     } catch (std::out_of_range& e) {
99244       {
99245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99246       };
99247     } catch (std::exception& e) {
99248       {
99249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99250       };
99251     } catch (Dali::DaliException e) {
99252       {
99253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99254       };
99255     } catch (...) {
99256       {
99257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99258       };
99259     }
99260   }
99261
99262 }
99263
99264
99265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99266   unsigned int jresult ;
99267   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99268   bool result;
99269
99270   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99271   {
99272     try {
99273       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99274     } catch (std::out_of_range& e) {
99275       {
99276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99277       };
99278     } catch (std::exception& e) {
99279       {
99280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99281       };
99282     } catch (Dali::DaliException e) {
99283       {
99284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99285       };
99286     } catch (...) {
99287       {
99288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99289       };
99290     }
99291   }
99292
99293   jresult = result;
99294   return jresult;
99295 }
99296
99297
99298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99299   unsigned long jresult ;
99300   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99301   std::size_t result;
99302
99303   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99304   {
99305     try {
99306       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99307     } catch (std::out_of_range& e) {
99308       {
99309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99310       };
99311     } catch (std::exception& e) {
99312       {
99313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99314       };
99315     } catch (Dali::DaliException e) {
99316       {
99317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99318       };
99319     } catch (...) {
99320       {
99321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99322       };
99323     }
99324   }
99325
99326   jresult = (unsigned long)result;
99327   return jresult;
99328 }
99329
99330
99331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99332   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99333   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99334
99335   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99336   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99337   {
99338     try {
99339       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99340     } catch (std::out_of_range& e) {
99341       {
99342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99343       };
99344     } catch (std::exception& e) {
99345       {
99346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99347       };
99348     } catch (Dali::DaliException e) {
99349       {
99350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99351       };
99352     } catch (...) {
99353       {
99354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99355       };
99356     }
99357   }
99358
99359 }
99360
99361
99362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99363   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99364   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99365
99366   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99367   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99368   {
99369     try {
99370       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99371     } catch (std::out_of_range& e) {
99372       {
99373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99374       };
99375     } catch (std::exception& e) {
99376       {
99377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99378       };
99379     } catch (Dali::DaliException e) {
99380       {
99381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99382       };
99383     } catch (...) {
99384       {
99385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99386       };
99387     }
99388   }
99389
99390 }
99391
99392
99393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99394   unsigned int jresult ;
99395   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99396   Dali::Toolkit::Slider arg2 ;
99397   int arg3 ;
99398   Dali::Toolkit::Slider *argp2 ;
99399   bool result;
99400
99401   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99402   argp2 = (Dali::Toolkit::Slider *)jarg2;
99403   if (!argp2) {
99404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99405     return 0;
99406   }
99407   arg2 = *argp2;
99408   arg3 = (int)jarg3;
99409   {
99410     try {
99411       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99412     } catch (std::out_of_range& e) {
99413       {
99414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99415       };
99416     } catch (std::exception& e) {
99417       {
99418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99419       };
99420     } catch (Dali::DaliException e) {
99421       {
99422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99423       };
99424     } catch (...) {
99425       {
99426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99427       };
99428     }
99429   }
99430
99431   jresult = result;
99432   return jresult;
99433 }
99434
99435
99436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99437   void * jresult ;
99438   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99439
99440   {
99441     try {
99442       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99443     } catch (std::out_of_range& e) {
99444       {
99445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99446       };
99447     } catch (std::exception& e) {
99448       {
99449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99450       };
99451     } catch (Dali::DaliException e) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99454       };
99455     } catch (...) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99458       };
99459     }
99460   }
99461
99462   jresult = (void *)result;
99463   return jresult;
99464 }
99465
99466
99467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99468   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99469
99470   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99471   {
99472     try {
99473       delete arg1;
99474     } catch (std::out_of_range& e) {
99475       {
99476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99477       };
99478     } catch (std::exception& e) {
99479       {
99480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99481       };
99482     } catch (Dali::DaliException e) {
99483       {
99484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99485       };
99486     } catch (...) {
99487       {
99488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99489       };
99490     }
99491   }
99492
99493 }
99494
99495
99496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99497   void * jresult ;
99498   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99499
99500   {
99501     try {
99502       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99503     } catch (std::out_of_range& e) {
99504       {
99505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99506       };
99507     } catch (std::exception& e) {
99508       {
99509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99510       };
99511     } catch (Dali::DaliException e) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99514       };
99515     } catch (...) {
99516       {
99517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99518       };
99519     }
99520   }
99521
99522   jresult = (void *)result;
99523   return jresult;
99524 }
99525
99526
99527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99528   void * jresult ;
99529   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99530   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99531
99532   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99533   {
99534     try {
99535       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99536     } catch (std::out_of_range& e) {
99537       {
99538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99539       };
99540     } catch (std::exception& e) {
99541       {
99542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99543       };
99544     } catch (Dali::DaliException e) {
99545       {
99546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99547       };
99548     } catch (...) {
99549       {
99550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99551       };
99552     }
99553   }
99554
99555   jresult = (void *)result;
99556   return jresult;
99557 }
99558
99559
99560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99561   void * jresult ;
99562   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99563   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99564
99565   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99566   if (!arg1) {
99567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99568     return 0;
99569   }
99570   {
99571     try {
99572       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99573     } catch (std::out_of_range& e) {
99574       {
99575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99576       };
99577     } catch (std::exception& e) {
99578       {
99579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99580       };
99581     } catch (Dali::DaliException e) {
99582       {
99583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99584       };
99585     } catch (...) {
99586       {
99587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99588       };
99589     }
99590   }
99591
99592   jresult = (void *)result;
99593   return jresult;
99594 }
99595
99596
99597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99598   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99599
99600   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99601   {
99602     try {
99603       delete arg1;
99604     } catch (std::out_of_range& e) {
99605       {
99606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99607       };
99608     } catch (std::exception& e) {
99609       {
99610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99611       };
99612     } catch (Dali::DaliException e) {
99613       {
99614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99615       };
99616     } catch (...) {
99617       {
99618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99619       };
99620     }
99621   }
99622
99623 }
99624
99625
99626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99627   void * jresult ;
99628   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99629   Dali::Toolkit::Ruler *result = 0 ;
99630
99631   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99632   {
99633     try {
99634       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99635     } catch (std::out_of_range& e) {
99636       {
99637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99638       };
99639     } catch (std::exception& e) {
99640       {
99641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99642       };
99643     } catch (Dali::DaliException e) {
99644       {
99645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99646       };
99647     } catch (...) {
99648       {
99649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99650       };
99651     }
99652   }
99653
99654   jresult = (void *)result;
99655   return jresult;
99656 }
99657
99658
99659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99660   void * jresult ;
99661   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99662   Dali::Toolkit::Ruler *result = 0 ;
99663
99664   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99665   {
99666     try {
99667       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99668     } catch (std::out_of_range& e) {
99669       {
99670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99671       };
99672     } catch (std::exception& e) {
99673       {
99674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99675       };
99676     } catch (Dali::DaliException e) {
99677       {
99678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99679       };
99680     } catch (...) {
99681       {
99682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99683       };
99684     }
99685   }
99686
99687   jresult = (void *)result;
99688   return jresult;
99689 }
99690
99691
99692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99693   void * jresult ;
99694   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99695   Dali::Toolkit::Ruler *result = 0 ;
99696
99697   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99698   {
99699     try {
99700       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99701     } catch (std::out_of_range& e) {
99702       {
99703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99704       };
99705     } catch (std::exception& e) {
99706       {
99707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99708       };
99709     } catch (Dali::DaliException e) {
99710       {
99711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99712       };
99713     } catch (...) {
99714       {
99715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99716       };
99717     }
99718   }
99719
99720   jresult = (void *)result;
99721   return jresult;
99722 }
99723
99724
99725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99726   void * jresult ;
99727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99729   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99730
99731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99732   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99733   if (!arg2) {
99734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99735     return 0;
99736   }
99737   {
99738     try {
99739       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99740     } catch (std::out_of_range& e) {
99741       {
99742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99743       };
99744     } catch (std::exception& e) {
99745       {
99746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99747       };
99748     } catch (Dali::DaliException e) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99751       };
99752     } catch (...) {
99753       {
99754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99755       };
99756     }
99757   }
99758
99759   jresult = (void *)result;
99760   return jresult;
99761 }
99762
99763
99764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99765   void * jresult ;
99766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99767   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99768   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99769
99770   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99771   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99772   {
99773     try {
99774       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99775     } catch (std::out_of_range& e) {
99776       {
99777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99778       };
99779     } catch (std::exception& e) {
99780       {
99781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99782       };
99783     } catch (Dali::DaliException e) {
99784       {
99785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99786       };
99787     } catch (...) {
99788       {
99789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99790       };
99791     }
99792   }
99793
99794   jresult = (void *)result;
99795   return jresult;
99796 }
99797
99798
99799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99800   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99801
99802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99803   {
99804     try {
99805       (arg1)->Reset();
99806     } catch (std::out_of_range& e) {
99807       {
99808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99809       };
99810     } catch (std::exception& e) {
99811       {
99812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99813       };
99814     } catch (Dali::DaliException e) {
99815       {
99816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99817       };
99818     } catch (...) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99821       };
99822     }
99823   }
99824
99825 }
99826
99827
99828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99829   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99830   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99831
99832   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99833   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99834   {
99835     try {
99836       (arg1)->Reset(arg2);
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99852       };
99853     }
99854   }
99855
99856 }
99857
99858
99859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99860   void * jresult ;
99861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99862   Dali::Toolkit::Ruler *result = 0 ;
99863
99864   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99865   {
99866     try {
99867       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99868     } catch (std::out_of_range& e) {
99869       {
99870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99871       };
99872     } catch (std::exception& e) {
99873       {
99874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99875       };
99876     } catch (Dali::DaliException e) {
99877       {
99878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99879       };
99880     } catch (...) {
99881       {
99882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99883       };
99884     }
99885   }
99886
99887   jresult = (void *)result;
99888   return jresult;
99889 }
99890
99891
99892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99893   float jresult ;
99894   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99895   float arg2 ;
99896   float arg3 ;
99897   float result;
99898
99899   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99900   arg2 = (float)jarg2;
99901   arg3 = (float)jarg3;
99902   {
99903     try {
99904       result = (float)(*arg1)->Snap(arg2,arg3);
99905     } catch (std::out_of_range& e) {
99906       {
99907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99908       };
99909     } catch (std::exception& e) {
99910       {
99911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99912       };
99913     } catch (Dali::DaliException e) {
99914       {
99915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99916       };
99917     } catch (...) {
99918       {
99919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99920       };
99921     }
99922   }
99923
99924   jresult = result;
99925   return jresult;
99926 }
99927
99928
99929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99930   float jresult ;
99931   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99932   float arg2 ;
99933   float result;
99934
99935   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99936   arg2 = (float)jarg2;
99937   {
99938     try {
99939       result = (float)(*arg1)->Snap(arg2);
99940     } catch (std::out_of_range& e) {
99941       {
99942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99943       };
99944     } catch (std::exception& e) {
99945       {
99946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99947       };
99948     } catch (Dali::DaliException e) {
99949       {
99950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99951       };
99952     } catch (...) {
99953       {
99954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99955       };
99956     }
99957   }
99958
99959   jresult = result;
99960   return jresult;
99961 }
99962
99963
99964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99965   float jresult ;
99966   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99967   unsigned int arg2 ;
99968   unsigned int *arg3 = 0 ;
99969   bool arg4 ;
99970   float result;
99971
99972   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99973   arg2 = (unsigned int)jarg2;
99974   arg3 = (unsigned int *)jarg3;
99975   arg4 = jarg4 ? true : false;
99976   {
99977     try {
99978       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99979     } catch (std::out_of_range& e) {
99980       {
99981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99982       };
99983     } catch (std::exception& e) {
99984       {
99985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99986       };
99987     } catch (Dali::DaliException e) {
99988       {
99989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99990       };
99991     } catch (...) {
99992       {
99993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99994       };
99995     }
99996   }
99997
99998   jresult = result;
99999   return jresult;
100000 }
100001
100002
100003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100004   unsigned int jresult ;
100005   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100006   float arg2 ;
100007   bool arg3 ;
100008   unsigned int result;
100009
100010   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100011   arg2 = (float)jarg2;
100012   arg3 = jarg3 ? true : false;
100013   {
100014     try {
100015       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100016     } catch (std::out_of_range& e) {
100017       {
100018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100019       };
100020     } catch (std::exception& e) {
100021       {
100022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100023       };
100024     } catch (Dali::DaliException e) {
100025       {
100026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100027       };
100028     } catch (...) {
100029       {
100030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100031       };
100032     }
100033   }
100034
100035   jresult = result;
100036   return jresult;
100037 }
100038
100039
100040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100041   unsigned int jresult ;
100042   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100043   unsigned int result;
100044
100045   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100046   {
100047     try {
100048       result = (unsigned int)(*arg1)->GetTotalPages();
100049     } catch (std::out_of_range& e) {
100050       {
100051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100052       };
100053     } catch (std::exception& e) {
100054       {
100055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100056       };
100057     } catch (Dali::DaliException e) {
100058       {
100059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100060       };
100061     } catch (...) {
100062       {
100063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100064       };
100065     }
100066   }
100067
100068   jresult = result;
100069   return jresult;
100070 }
100071
100072
100073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100074   int jresult ;
100075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100076   Dali::Toolkit::Ruler::RulerType result;
100077
100078   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100079   {
100080     try {
100081       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100082     } catch (std::out_of_range& e) {
100083       {
100084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100085       };
100086     } catch (std::exception& e) {
100087       {
100088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100089       };
100090     } catch (Dali::DaliException e) {
100091       {
100092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100093       };
100094     } catch (...) {
100095       {
100096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100097       };
100098     }
100099   }
100100
100101   jresult = (int)result;
100102   return jresult;
100103 }
100104
100105
100106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100107   unsigned int jresult ;
100108   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100109   bool result;
100110
100111   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100112   {
100113     try {
100114       result = (bool)(*arg1)->IsEnabled();
100115     } catch (std::out_of_range& e) {
100116       {
100117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100118       };
100119     } catch (std::exception& e) {
100120       {
100121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100122       };
100123     } catch (Dali::DaliException e) {
100124       {
100125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100126       };
100127     } catch (...) {
100128       {
100129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100130       };
100131     }
100132   }
100133
100134   jresult = result;
100135   return jresult;
100136 }
100137
100138
100139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100141
100142   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100143   {
100144     try {
100145       (*arg1)->Enable();
100146     } catch (std::out_of_range& e) {
100147       {
100148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100149       };
100150     } catch (std::exception& e) {
100151       {
100152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100153       };
100154     } catch (Dali::DaliException e) {
100155       {
100156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100157       };
100158     } catch (...) {
100159       {
100160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100161       };
100162     }
100163   }
100164
100165 }
100166
100167
100168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100169   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100170
100171   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100172   {
100173     try {
100174       (*arg1)->Disable();
100175     } catch (std::out_of_range& e) {
100176       {
100177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100178       };
100179     } catch (std::exception& e) {
100180       {
100181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100182       };
100183     } catch (Dali::DaliException e) {
100184       {
100185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100186       };
100187     } catch (...) {
100188       {
100189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100190       };
100191     }
100192   }
100193
100194 }
100195
100196
100197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100199   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100200   Dali::Toolkit::RulerDomain *argp2 ;
100201
100202   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100203   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100204   if (!argp2) {
100205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100206     return ;
100207   }
100208   arg2 = *argp2;
100209   {
100210     try {
100211       (*arg1)->SetDomain(arg2);
100212     } catch (std::out_of_range& e) {
100213       {
100214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100215       };
100216     } catch (std::exception& e) {
100217       {
100218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100219       };
100220     } catch (Dali::DaliException e) {
100221       {
100222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100223       };
100224     } catch (...) {
100225       {
100226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100227       };
100228     }
100229   }
100230
100231 }
100232
100233
100234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100235   void * jresult ;
100236   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100237   Dali::Toolkit::RulerDomain *result = 0 ;
100238
100239   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100240   {
100241     try {
100242       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100243     } catch (std::out_of_range& e) {
100244       {
100245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100246       };
100247     } catch (std::exception& e) {
100248       {
100249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100250       };
100251     } catch (Dali::DaliException e) {
100252       {
100253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100254       };
100255     } catch (...) {
100256       {
100257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100258       };
100259     }
100260   }
100261
100262   jresult = (void *)result;
100263   return jresult;
100264 }
100265
100266
100267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100268   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100269
100270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100271   {
100272     try {
100273       (*arg1)->DisableDomain();
100274     } catch (std::out_of_range& e) {
100275       {
100276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100277       };
100278     } catch (std::exception& e) {
100279       {
100280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100281       };
100282     } catch (Dali::DaliException e) {
100283       {
100284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100285       };
100286     } catch (...) {
100287       {
100288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100289       };
100290     }
100291   }
100292
100293 }
100294
100295
100296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100297   float jresult ;
100298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100299   float arg2 ;
100300   float arg3 ;
100301   float arg4 ;
100302   float result;
100303
100304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100305   arg2 = (float)jarg2;
100306   arg3 = (float)jarg3;
100307   arg4 = (float)jarg4;
100308   {
100309     try {
100310       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100326       };
100327     }
100328   }
100329
100330   jresult = result;
100331   return jresult;
100332 }
100333
100334
100335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100336   float jresult ;
100337   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100338   float arg2 ;
100339   float arg3 ;
100340   float result;
100341
100342   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100343   arg2 = (float)jarg2;
100344   arg3 = (float)jarg3;
100345   {
100346     try {
100347       result = (float)(*arg1)->Clamp(arg2,arg3);
100348     } catch (std::out_of_range& e) {
100349       {
100350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100351       };
100352     } catch (std::exception& e) {
100353       {
100354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100355       };
100356     } catch (Dali::DaliException e) {
100357       {
100358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100359       };
100360     } catch (...) {
100361       {
100362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100363       };
100364     }
100365   }
100366
100367   jresult = result;
100368   return jresult;
100369 }
100370
100371
100372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100373   float jresult ;
100374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100375   float arg2 ;
100376   float result;
100377
100378   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100379   arg2 = (float)jarg2;
100380   {
100381     try {
100382       result = (float)(*arg1)->Clamp(arg2);
100383     } catch (std::out_of_range& e) {
100384       {
100385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100386       };
100387     } catch (std::exception& e) {
100388       {
100389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100390       };
100391     } catch (Dali::DaliException e) {
100392       {
100393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100394       };
100395     } catch (...) {
100396       {
100397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100398       };
100399     }
100400   }
100401
100402   jresult = result;
100403   return jresult;
100404 }
100405
100406
100407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100408   float jresult ;
100409   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100410   float arg2 ;
100411   float arg3 ;
100412   float arg4 ;
100413   Dali::Toolkit::ClampState *arg5 = 0 ;
100414   float result;
100415
100416   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100417   arg2 = (float)jarg2;
100418   arg3 = (float)jarg3;
100419   arg4 = (float)jarg4;
100420   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100421   if (!arg5) {
100422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100423     return 0;
100424   }
100425   {
100426     try {
100427       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100428     } catch (std::out_of_range& e) {
100429       {
100430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100431       };
100432     } catch (std::exception& e) {
100433       {
100434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100435       };
100436     } catch (Dali::DaliException e) {
100437       {
100438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100439       };
100440     } catch (...) {
100441       {
100442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100443       };
100444     }
100445   }
100446
100447   jresult = result;
100448   return jresult;
100449 }
100450
100451
100452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100453   float jresult ;
100454   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100455   float arg2 ;
100456   float arg3 ;
100457   float arg4 ;
100458   float arg5 ;
100459   float result;
100460
100461   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100462   arg2 = (float)jarg2;
100463   arg3 = (float)jarg3;
100464   arg4 = (float)jarg4;
100465   arg5 = (float)jarg5;
100466   {
100467     try {
100468       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100469     } catch (std::out_of_range& e) {
100470       {
100471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100472       };
100473     } catch (std::exception& e) {
100474       {
100475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100476       };
100477     } catch (Dali::DaliException e) {
100478       {
100479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100480       };
100481     } catch (...) {
100482       {
100483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100484       };
100485     }
100486   }
100487
100488   jresult = result;
100489   return jresult;
100490 }
100491
100492
100493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100494   float jresult ;
100495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100496   float arg2 ;
100497   float arg3 ;
100498   float arg4 ;
100499   float result;
100500
100501   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100502   arg2 = (float)jarg2;
100503   arg3 = (float)jarg3;
100504   arg4 = (float)jarg4;
100505   {
100506     try {
100507       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100508     } catch (std::out_of_range& e) {
100509       {
100510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100511       };
100512     } catch (std::exception& e) {
100513       {
100514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100515       };
100516     } catch (Dali::DaliException e) {
100517       {
100518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100519       };
100520     } catch (...) {
100521       {
100522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100523       };
100524     }
100525   }
100526
100527   jresult = result;
100528   return jresult;
100529 }
100530
100531
100532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100533   float jresult ;
100534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100535   float arg2 ;
100536   float arg3 ;
100537   float result;
100538
100539   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100540   arg2 = (float)jarg2;
100541   arg3 = (float)jarg3;
100542   {
100543     try {
100544       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100545     } catch (std::out_of_range& e) {
100546       {
100547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100548       };
100549     } catch (std::exception& e) {
100550       {
100551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100552       };
100553     } catch (Dali::DaliException e) {
100554       {
100555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100556       };
100557     } catch (...) {
100558       {
100559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100560       };
100561     }
100562   }
100563
100564   jresult = result;
100565   return jresult;
100566 }
100567
100568
100569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100570   float jresult ;
100571   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100572   float arg2 ;
100573   float result;
100574
100575   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100576   arg2 = (float)jarg2;
100577   {
100578     try {
100579       result = (float)(*arg1)->SnapAndClamp(arg2);
100580     } catch (std::out_of_range& e) {
100581       {
100582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100583       };
100584     } catch (std::exception& e) {
100585       {
100586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100587       };
100588     } catch (Dali::DaliException e) {
100589       {
100590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100591       };
100592     } catch (...) {
100593       {
100594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100595       };
100596     }
100597   }
100598
100599   jresult = result;
100600   return jresult;
100601 }
100602
100603
100604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100605   float jresult ;
100606   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100607   float arg2 ;
100608   float arg3 ;
100609   float arg4 ;
100610   float arg5 ;
100611   Dali::Toolkit::ClampState *arg6 = 0 ;
100612   float result;
100613
100614   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100615   arg2 = (float)jarg2;
100616   arg3 = (float)jarg3;
100617   arg4 = (float)jarg4;
100618   arg5 = (float)jarg5;
100619   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100620   if (!arg6) {
100621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100622     return 0;
100623   }
100624   {
100625     try {
100626       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
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 void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100652   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100653
100654   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100655   {
100656     try {
100657       (*arg1)->Reference();
100658     } catch (std::out_of_range& e) {
100659       {
100660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100661       };
100662     } catch (std::exception& e) {
100663       {
100664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100665       };
100666     } catch (Dali::DaliException e) {
100667       {
100668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100669       };
100670     } catch (...) {
100671       {
100672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100673       };
100674     }
100675   }
100676
100677 }
100678
100679
100680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100681   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100682
100683   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100684   {
100685     try {
100686       (*arg1)->Unreference();
100687     } catch (std::out_of_range& e) {
100688       {
100689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100690       };
100691     } catch (std::exception& e) {
100692       {
100693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100694       };
100695     } catch (Dali::DaliException e) {
100696       {
100697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100698       };
100699     } catch (...) {
100700       {
100701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100702       };
100703     }
100704   }
100705
100706 }
100707
100708
100709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100710   int jresult ;
100711   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100712   int result;
100713
100714   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100715   {
100716     try {
100717       result = (int)(*arg1)->ReferenceCount();
100718     } catch (std::out_of_range& e) {
100719       {
100720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100721       };
100722     } catch (std::exception& e) {
100723       {
100724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100725       };
100726     } catch (Dali::DaliException e) {
100727       {
100728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100729       };
100730     } catch (...) {
100731       {
100732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100733       };
100734     }
100735   }
100736
100737   jresult = result;
100738   return jresult;
100739 }
100740
100741
100742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100743   unsigned int jresult ;
100744   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100745   bool result;
100746
100747   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100748   {
100749     try {
100750       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100751     } catch (std::out_of_range& e) {
100752       {
100753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100754       };
100755     } catch (std::exception& e) {
100756       {
100757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100758       };
100759     } catch (Dali::DaliException e) {
100760       {
100761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100762       };
100763     } catch (...) {
100764       {
100765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100766       };
100767     }
100768   }
100769
100770   jresult = result;
100771   return jresult;
100772 }
100773
100774
100775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100776   unsigned long jresult ;
100777   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100778   std::size_t result;
100779
100780   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100781   {
100782     try {
100783       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100784     } catch (std::out_of_range& e) {
100785       {
100786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100787       };
100788     } catch (std::exception& e) {
100789       {
100790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100791       };
100792     } catch (Dali::DaliException e) {
100793       {
100794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100795       };
100796     } catch (...) {
100797       {
100798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100799       };
100800     }
100801   }
100802
100803   jresult = (unsigned long)result;
100804   return jresult;
100805 }
100806
100807
100808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100809   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100810   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100811
100812   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100813   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100814   {
100815     try {
100816       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100817     } catch (std::out_of_range& e) {
100818       {
100819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100820       };
100821     } catch (std::exception& e) {
100822       {
100823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100824       };
100825     } catch (Dali::DaliException e) {
100826       {
100827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100828       };
100829     } catch (...) {
100830       {
100831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100832       };
100833     }
100834   }
100835
100836 }
100837
100838
100839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100840   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100841   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100842
100843   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100844   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100845   {
100846     try {
100847       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100848     } catch (std::out_of_range& e) {
100849       {
100850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100851       };
100852     } catch (std::exception& e) {
100853       {
100854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100855       };
100856     } catch (Dali::DaliException e) {
100857       {
100858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100859       };
100860     } catch (...) {
100861       {
100862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100863       };
100864     }
100865   }
100866
100867 }
100868
100869
100870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100871   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100872   Dali::Toolkit::Control arg2 ;
100873   Dali::Toolkit::Control *argp2 ;
100874
100875   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100876   argp2 = (Dali::Toolkit::Control *)jarg2;
100877   if (!argp2) {
100878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100879     return ;
100880   }
100881   arg2 = *argp2;
100882   {
100883     try {
100884       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100885     } catch (std::out_of_range& e) {
100886       {
100887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100888       };
100889     } catch (std::exception& e) {
100890       {
100891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100892       };
100893     } catch (Dali::DaliException e) {
100894       {
100895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100896       };
100897     } catch (...) {
100898       {
100899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100900       };
100901     }
100902   }
100903
100904 }
100905
100906
100907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100908   void * jresult ;
100909   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100910
100911   {
100912     try {
100913       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100914     } catch (std::out_of_range& e) {
100915       {
100916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100917       };
100918     } catch (std::exception& e) {
100919       {
100920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100921       };
100922     } catch (Dali::DaliException e) {
100923       {
100924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100925       };
100926     } catch (...) {
100927       {
100928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100929       };
100930     }
100931   }
100932
100933   jresult = (void *)result;
100934   return jresult;
100935 }
100936
100937
100938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100939   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100940
100941   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100942   {
100943     try {
100944       delete arg1;
100945     } catch (std::out_of_range& e) {
100946       {
100947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100948       };
100949     } catch (std::exception& e) {
100950       {
100951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100952       };
100953     } catch (Dali::DaliException e) {
100954       {
100955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100956       };
100957     } catch (...) {
100958       {
100959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100960       };
100961     }
100962   }
100963
100964 }
100965
100966 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100967   Dali::RefObject *result = NULL;
100968
100969   if (arg1)
100970   {
100971     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100972   }
100973   return result;
100974 }
100975
100976 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100977     return (Dali::RefObject *)jarg1;
100978 }
100979
100980 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100981     return (Dali::SignalObserver *)jarg1;
100982 }
100983
100984 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100985     return (Dali::ConnectionTrackerInterface *)jarg1;
100986 }
100987
100988 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100989     return (Dali::BaseHandle *)jarg1;
100990 }
100991
100992 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100993     return (Dali::BaseHandle *)jarg1;
100994 }
100995
100996 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100997     return (Dali::BaseHandle *)jarg1;
100998 }
100999
101000 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101001     return (Dali::BaseHandle *)jarg1;
101002 }
101003
101004 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101005     return (Dali::BaseHandle *)jarg1;
101006 }
101007
101008 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101009     return (Dali::BaseHandle *)jarg1;
101010 }
101011
101012 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101013     return (Dali::BaseHandle *)jarg1;
101014 }
101015
101016 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101017     return (Dali::BaseHandle *)jarg1;
101018 }
101019
101020 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101021     return (Dali::BaseHandle *)jarg1;
101022 }
101023
101024 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101025     return (Dali::BaseHandle *)jarg1;
101026 }
101027
101028 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101029     return (Dali::BaseHandle *)jarg1;
101030 }
101031
101032 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101033     return (Dali::BaseHandle *)jarg1;
101034 }
101035
101036 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101037     return (Dali::BaseHandle *)jarg1;
101038 }
101039
101040 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101041     return (Dali::Handle *)jarg1;
101042 }
101043
101044 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101045     return (Dali::Handle *)jarg1;
101046 }
101047
101048 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101049     return (Dali::BaseHandle *)jarg1;
101050 }
101051
101052 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101053     return (Dali::BaseHandle *)jarg1;
101054 }
101055
101056 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101057     return (Dali::Handle *)jarg1;
101058 }
101059
101060 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101061     return (Dali::BaseHandle *)jarg1;
101062 }
101063
101064 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101065     return (Dali::Handle *)jarg1;
101066 }
101067
101068 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101069     return (Dali::GestureDetector *)jarg1;
101070 }
101071
101072 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101073     return (Dali::Gesture *)jarg1;
101074 }
101075
101076 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101077     return (Dali::Handle *)jarg1;
101078 }
101079
101080 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101081     return (Dali::Actor *)jarg1;
101082 }
101083
101084 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101085     return (Dali::BaseHandle *)jarg1;
101086 }
101087
101088 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101089     return (Dali::RefObject *)jarg1;
101090 }
101091
101092 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101093     return (Dali::Actor *)jarg1;
101094 }
101095
101096 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101097     return (Dali::GestureDetector *)jarg1;
101098 }
101099
101100 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101101     return (Dali::Gesture *)jarg1;
101102 }
101103
101104 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101105     return (Dali::GestureDetector *)jarg1;
101106 }
101107
101108 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101109     return (Dali::Gesture *)jarg1;
101110 }
101111
101112 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101113     return (Dali::GestureDetector *)jarg1;
101114 }
101115
101116 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101117     return (Dali::Gesture *)jarg1;
101118 }
101119
101120 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101121     return (Dali::BaseHandle *)jarg1;
101122 }
101123
101124 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101125     return (Dali::Handle *)jarg1;
101126 }
101127
101128 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101129     return (Dali::Handle *)jarg1;
101130 }
101131
101132 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101133     return (Dali::Handle *)jarg1;
101134 }
101135
101136 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101137     return (Dali::Image *)jarg1;
101138 }
101139
101140 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101141     return (Dali::Image *)jarg1;
101142 }
101143
101144 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101145     return (Dali::Image *)jarg1;
101146 }
101147
101148 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101149     return (Dali::RefObject *)jarg1;
101150 }
101151
101152 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101153     return (Dali::Image *)jarg1;
101154 }
101155
101156 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101157     return (Dali::Image *)jarg1;
101158 }
101159
101160 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101161     return (Dali::ResourceImage *)jarg1;
101162 }
101163
101164 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101165     return (Dali::Actor *)jarg1;
101166 }
101167
101168 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101169     return (Dali::BaseHandle *)jarg1;
101170 }
101171
101172 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101173     return (Dali::BaseHandle *)jarg1;
101174 }
101175
101176
101177 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101178     return (Dali::BaseHandle *)jarg1;
101179 }
101180
101181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101182     return (Dali::BaseHandle *)jarg1;
101183 }
101184
101185 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101186     return (Dali::CustomActorImpl *)jarg1;
101187 }
101188
101189 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101190     return (Dali::CustomActor *)jarg1;
101191 }
101192
101193 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101194     return (Dali::BaseHandle *)jarg1;
101195 }
101196
101197 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101198     return (Dali::Toolkit::Control *)jarg1;
101199 }
101200
101201 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101202     return (Dali::Toolkit::Control *)jarg1;
101203 }
101204
101205 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101206     return (Dali::Toolkit::Button *)jarg1;
101207 }
101208
101209 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101210     return (Dali::Toolkit::Button *)jarg1;
101211 }
101212
101213 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101214     return (Dali::Toolkit::Button *)jarg1;
101215 }
101216
101217 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101218     return (Dali::Toolkit::Control *)jarg1;
101219 }
101220
101221 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101222     return (Dali::Toolkit::Control *)jarg1;
101223 }
101224
101225 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101226     return (Dali::Toolkit::Control *)jarg1;
101227 }
101228
101229 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101230     return (Dali::Toolkit::Control *)jarg1;
101231 }
101232
101233 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101234     return (Dali::Toolkit::Control *)jarg1;
101235 }
101236
101237 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101238     return (Dali::RefObject *)jarg1;
101239 }
101240
101241 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101242     return (Dali::Toolkit::Scrollable *)jarg1;
101243 }
101244
101245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101246     return (Dali::BaseHandle *)jarg1;
101247 }
101248
101249 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101250     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101251 }
101252
101253 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101254     return (Dali::RefObject *)jarg1;
101255 }
101256
101257 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101258     return (Dali::Toolkit::Ruler *)jarg1;
101259 }
101260
101261 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101262     return (Dali::Toolkit::Ruler *)jarg1;
101263 }
101264
101265 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101266     return (Dali::Toolkit::Scrollable *)jarg1;
101267 }
101268
101269 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101270     return (Dali::Toolkit::Control *)jarg1;
101271 }
101272
101273
101274 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101275     return (Dali::Toolkit::Control *)jarg1;
101276 }
101277
101278 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101279     return (Dali::BaseHandle *)jarg1;
101280 }
101281
101282 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101283     return (Dali::BaseHandle *)jarg1;
101284 }
101285
101286 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101287     return (Dali::Toolkit::Control *)jarg1;
101288 }
101289
101290 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101291     return (Dali::Toolkit::Control *)jarg1;
101292 }
101293
101294 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101295     return (Dali::Toolkit::Control *)jarg1;
101296 }
101297
101298 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101299     return (Dali::Toolkit::Control *)jarg1;
101300 }
101301
101302 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101303     return (Dali::Toolkit::Control *)jarg1;
101304 }
101305
101306 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101307     return (Dali::Toolkit::Control *)jarg1;
101308 }
101309
101310 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101311     return (Dali::Toolkit::PageTurnView *)jarg1;
101312 }
101313
101314 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101315     return (Dali::Toolkit::PageTurnView *)jarg1;
101316 }
101317
101318 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101319     return (Dali::Toolkit::Button *)jarg1;
101320 }
101321
101322 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101323     return (Dali::BaseHandle *)jarg1;
101324 }
101325
101326 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101327     return (Dali::BaseHandle *)jarg1;
101328 }
101329
101330 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101331     return (Dali::BaseHandle *)jarg1;
101332 }
101333
101334 /*
101335  * Widget binding
101336  */
101337 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101338     return (Dali::BaseHandle *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101342     return (Dali::BaseObject *)jarg1;
101343 }
101344
101345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101346   void * jresult ;
101347   Dali::Widget result;
101348
101349   {
101350     try {
101351       result = Dali::Widget::New();
101352     } catch (std::out_of_range& e) {
101353       {
101354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101355       };
101356     } catch (std::exception& e) {
101357       {
101358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101359       };
101360     } catch (...) {
101361       {
101362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101363       };
101364     }
101365   }
101366   jresult = new Dali::Widget((const Dali::Widget &)result);
101367   return jresult;
101368 }
101369
101370
101371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101372   void * jresult ;
101373   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101374   Dali::Widget result;
101375
101376   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101377
101378   if (!arg1) {
101379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101380     return 0;
101381   }
101382   {
101383     try {
101384       jresult = new Dali::Widget(arg1);
101385     } catch (std::out_of_range& e) {
101386       {
101387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101388       };
101389     } catch (std::exception& e) {
101390       {
101391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101392       };
101393     } catch (...) {
101394       {
101395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101396       };
101397     }
101398   }
101399   return jresult;
101400 }
101401
101402
101403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101404   void * jresult ;
101405   Dali::Widget *result = 0 ;
101406
101407   {
101408     try {
101409       result = (Dali::Widget *)new Dali::Widget();
101410     } catch (std::out_of_range& e) {
101411       {
101412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101413       };
101414     } catch (std::exception& e) {
101415       {
101416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101417       };
101418     } catch (...) {
101419       {
101420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101421       };
101422     }
101423   }
101424   jresult = (void *)result;
101425   return jresult;
101426 }
101427
101428
101429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101430   void * jresult ;
101431   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101432   Dali::Widget *arg2 = 0 ;
101433   Dali::Widget *result = 0 ;
101434
101435   arg1 = (Dali::Widget *)jarg1;
101436   arg2 = (Dali::Widget *)jarg2;
101437   if (!arg2) {
101438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101439     return 0;
101440   }
101441   {
101442     try {
101443       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101444     } catch (std::out_of_range& e) {
101445       {
101446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101447       };
101448     } catch (std::exception& e) {
101449       {
101450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101451       };
101452     } catch (...) {
101453       {
101454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101455       };
101456     }
101457   }
101458   jresult = (void *)result;
101459   return jresult;
101460 }
101461
101462
101463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101464   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101465
101466   arg1 = (Dali::Widget *)jarg1;
101467   {
101468     try {
101469       delete arg1;
101470     } catch (std::out_of_range& e) {
101471       {
101472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101473       };
101474     } catch (std::exception& e) {
101475       {
101476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101477       };
101478     } catch (...) {
101479       {
101480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101481       };
101482     }
101483   }
101484 }
101485
101486
101487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101488   void * jresult ;
101489   SwigDirector_WidgetImpl* result;
101490   {
101491     try {
101492       result = new SwigDirector_WidgetImpl();
101493     } catch (std::out_of_range& e) {
101494       {
101495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101496       };
101497     } catch (std::exception& e) {
101498       {
101499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101500       };
101501     } catch (...) {
101502       {
101503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101504       };
101505     }
101506   }
101507   jresult = result;
101508   return jresult;
101509 }
101510
101511
101512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101513   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101514   std::string *arg2 = 0 ;
101515   Dali::Window arg3 ;
101516   Dali::Window *argp3 ;
101517
101518   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101519   if (!jarg2) {
101520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101521     return ;
101522   }
101523   std::string arg2_str(jarg2);
101524   arg2 = &arg2_str;
101525   argp3 = (Dali::Window *)jarg3;
101526   if (!argp3) {
101527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101528     return ;
101529   }
101530   arg3 = *argp3;
101531   {
101532     try {
101533       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101534     } catch (std::out_of_range& e) {
101535       {
101536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101537       };
101538     } catch (std::exception& e) {
101539       {
101540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101541       };
101542     } catch (...) {
101543       {
101544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101545       };
101546     }
101547   }
101548 }
101549
101550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101551   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101552   std::string *arg2 = 0 ;
101553   Dali::Window arg3 ;
101554   Dali::Window *argp3 ;
101555
101556   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101557   if (!jarg2) {
101558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101559     return ;
101560   }
101561   std::string arg2_str(jarg2);
101562   arg2 = &arg2_str;
101563   argp3 = (Dali::Window *)jarg3;
101564   if (!argp3) {
101565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101566     return ;
101567   }
101568   arg3 = *argp3;
101569   {
101570     try {
101571       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101572     } catch (std::out_of_range& e) {
101573       {
101574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101575       };
101576     } catch (std::exception& e) {
101577       {
101578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101579       };
101580     } catch (...) {
101581       {
101582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101583       };
101584     }
101585   }
101586 }
101587
101588
101589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101590   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101591   std::string *arg2 = 0 ;
101592   Dali::Widget::Termination arg3 ;
101593
101594   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101595   if (!jarg2) {
101596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101597     return ;
101598   }
101599   std::string arg2_str(jarg2);
101600   arg2 = &arg2_str;
101601   arg3 = (Dali::Widget::Termination)jarg3;
101602   {
101603     try {
101604       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101605     } catch (std::out_of_range& e) {
101606       {
101607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101608       };
101609     } catch (std::exception& e) {
101610       {
101611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101612       };
101613     } catch (...) {
101614       {
101615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101616       };
101617     }
101618   }
101619 }
101620
101621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101622   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101623   std::string *arg2 = 0 ;
101624   Dali::Widget::Termination arg3 ;
101625
101626   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101627   if (!jarg2) {
101628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101629     return ;
101630   }
101631   std::string arg2_str(jarg2);
101632   arg2 = &arg2_str;
101633   arg3 = (Dali::Widget::Termination)jarg3;
101634   {
101635     try {
101636       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101637     } catch (std::out_of_range& e) {
101638       {
101639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101640       };
101641     } catch (std::exception& e) {
101642       {
101643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101644       };
101645     } catch (...) {
101646       {
101647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101648       };
101649     }
101650   }
101651 }
101652
101653
101654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101655   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101656
101657   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101658   {
101659     try {
101660       (arg1)->OnPause();
101661     } catch (std::out_of_range& e) {
101662       {
101663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101664       };
101665     } catch (std::exception& e) {
101666       {
101667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101668       };
101669     } catch (...) {
101670       {
101671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101672       };
101673     }
101674   }
101675 }
101676
101677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101678   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101679
101680   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101681   {
101682     try {
101683       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
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_OnResume(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)->OnResume();
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
101725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101726   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101727
101728   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101729   {
101730     try {
101731       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101732     } catch (std::out_of_range& e) {
101733       {
101734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101735       };
101736     } catch (std::exception& e) {
101737       {
101738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101739       };
101740     } catch (...) {
101741       {
101742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101743       };
101744     }
101745   }
101746 }
101747
101748
101749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101750   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101751   Dali::Window arg2 ;
101752   Dali::Window *argp2 ;
101753
101754   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101755   argp2 = (Dali::Window *)jarg2;
101756   if (!argp2) {
101757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101758     return ;
101759   }
101760   arg2 = *argp2;
101761   {
101762     try {
101763       (arg1)->OnResize(arg2);
101764     } catch (std::out_of_range& e) {
101765       {
101766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101767       };
101768     } catch (std::exception& e) {
101769       {
101770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101771       };
101772     } catch (...) {
101773       {
101774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101775       };
101776     }
101777   }
101778 }
101779
101780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101781   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101782   Dali::Window arg2 ;
101783   Dali::Window *argp2 ;
101784
101785   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101786   argp2 = (Dali::Window *)jarg2;
101787   if (!argp2) {
101788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101789     return ;
101790   }
101791   arg2 = *argp2;
101792   {
101793     try {
101794       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101795     } catch (std::out_of_range& e) {
101796       {
101797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101798       };
101799     } catch (std::exception& e) {
101800       {
101801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101802       };
101803     } catch (...) {
101804       {
101805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101806       };
101807     }
101808   }
101809 }
101810
101811
101812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101813   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101814   std::string *arg2 = 0 ;
101815   int arg3 ;
101816
101817   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101818   if (!jarg2) {
101819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101820     return ;
101821   }
101822   std::string arg2_str(jarg2);
101823   arg2 = &arg2_str;
101824   arg3 = (int)jarg3;
101825   {
101826     try {
101827       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101828     } catch (std::out_of_range& e) {
101829       {
101830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101831       };
101832     } catch (std::exception& e) {
101833       {
101834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101835       };
101836     } catch (...) {
101837       {
101838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101839       };
101840     }
101841   }
101842 }
101843
101844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101845   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101846   std::string *arg2 = 0 ;
101847   int arg3 ;
101848
101849   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101850   if (!jarg2) {
101851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101852     return ;
101853   }
101854   std::string arg2_str(jarg2);
101855   arg2 = &arg2_str;
101856   arg3 = (int)jarg3;
101857   {
101858     try {
101859       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101860     } catch (std::out_of_range& e) {
101861       {
101862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101863       };
101864     } catch (std::exception& e) {
101865       {
101866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101867       };
101868     } catch (...) {
101869       {
101870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101871       };
101872     }
101873   }
101874 }
101875
101876
101877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101878   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101879   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101880   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101881
101882   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101883   arg2 = (Dali::SlotObserver *)jarg2;
101884   arg3 = (Dali::CallbackBase *)jarg3;
101885   {
101886     try {
101887       (arg1)->SignalConnected(arg2,arg3);
101888     } catch (std::out_of_range& e) {
101889       {
101890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101891       };
101892     } catch (std::exception& e) {
101893       {
101894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101895       };
101896     } catch (...) {
101897       {
101898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101899       };
101900     }
101901   }
101902 }
101903
101904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101905   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101906   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101907   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101908
101909   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101910   arg2 = (Dali::SlotObserver *)jarg2;
101911   arg3 = (Dali::CallbackBase *)jarg3;
101912   {
101913     try {
101914       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101915     } catch (std::out_of_range& e) {
101916       {
101917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101918       };
101919     } catch (std::exception& e) {
101920       {
101921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101922       };
101923     } catch (...) {
101924       {
101925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101926       };
101927     }
101928   }
101929 }
101930
101931
101932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101933   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101934   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101935   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101936
101937   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101938   arg2 = (Dali::SlotObserver *)jarg2;
101939   arg3 = (Dali::CallbackBase *)jarg3;
101940   {
101941     try {
101942       (arg1)->SignalDisconnected(arg2,arg3);
101943     } catch (std::out_of_range& e) {
101944       {
101945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101946       };
101947     } catch (std::exception& e) {
101948       {
101949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101950       };
101951     } catch (...) {
101952       {
101953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101954       };
101955     }
101956   }
101957 }
101958
101959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101960   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101961   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101962   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101963
101964   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101965   arg2 = (Dali::SlotObserver *)jarg2;
101966   arg3 = (Dali::CallbackBase *)jarg3;
101967   {
101968     try {
101969       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101970     } catch (std::out_of_range& e) {
101971       {
101972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101973       };
101974     } catch (std::exception& e) {
101975       {
101976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101977       };
101978     } catch (...) {
101979       {
101980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101981       };
101982     }
101983   }
101984 }
101985
101986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101987   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101988   std::string *arg2 = 0 ;
101989
101990   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101991   if (!jarg2) {
101992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101993     return ;
101994   }
101995   std::string arg2_str(jarg2);
101996   arg2 = &arg2_str;
101997   {
101998     try {
101999       (arg1)->SetContentInfo((std::string const &)*arg2);
102000     } catch (std::out_of_range& e) {
102001       {
102002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102003       };
102004     } catch (std::exception& e) {
102005       {
102006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102007       };
102008     } catch (...) {
102009       {
102010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102011       };
102012     }
102013   }
102014 }
102015
102016
102017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102018   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102019   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102020
102021   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102022   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102023   {
102024     try {
102025       (arg1)->SetImpl(arg2);
102026     } catch (std::out_of_range& e) {
102027       {
102028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102029       };
102030     } catch (std::exception& e) {
102031       {
102032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102033       };
102034     } catch (...) {
102035       {
102036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102037       };
102038     }
102039   }
102040 }
102041
102042 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) {
102043
102044   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102045   if (director) {
102046     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102047   }
102048 }
102049
102050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102051   void * jresult ;
102052   Dali::Widget *arg1 = 0 ;
102053   SwigDirector_WidgetImpl *result = 0 ;
102054
102055   arg1 = (Dali::Widget *)jarg1;
102056   if (!arg1) {
102057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102058     return 0;
102059   }
102060   {
102061     try {
102062       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102063     } catch (std::out_of_range& e) {
102064       {
102065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102066       };
102067     } catch (std::exception& e) {
102068       {
102069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102070       };
102071     } catch (...) {
102072       {
102073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102074       };
102075     }
102076   }
102077
102078   jresult = (void *)result;
102079   return jresult;
102080 }
102081
102082
102083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102084   void * jresult ;
102085   int *arg1 = (int *) 0 ;
102086   char ***arg2 ;
102087   std::string *arg3 = 0 ;
102088   Dali::WidgetApplication result;
102089   {
102090     int index = 0;
102091     int length = 0;
102092     char *retPtr;
102093     char *nextPtr;
102094     argWidgetC = jarg1;
102095     argWidgetV = new char*[jarg1 + 1];
102096
102097     retPtr = strtok_r( jarg2, " ", &nextPtr);
102098     if( retPtr )
102099     {
102100       length = strlen(retPtr);
102101     }
102102     argWidgetV[index] = new char[length + 1];
102103     if( retPtr )
102104     {
102105       strncpy(argWidgetV[index], retPtr, length);
102106     }
102107     argWidgetV[index][length] = '\0';
102108     index++;
102109
102110     while (index < jarg1)
102111     {
102112       length = 0;
102113       retPtr = strtok_r(NULL, " ", &nextPtr);
102114       if( retPtr )
102115       {
102116         length = strlen(retPtr);
102117       }
102118       argWidgetV[index] = new char[length + 1];
102119       if( retPtr )
102120       {
102121         strncpy(argWidgetV[index], retPtr, length);
102122       }
102123       argWidgetV[index][length] = '\0';
102124       index++;
102125     }
102126
102127     argWidgetV[jarg1] = NULL;
102128     argWidgetC = jarg1;
102129
102130     arg1 = &argWidgetC;
102131     arg2 = &argWidgetV;
102132   }
102133
102134   if (!jarg3) {
102135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102136     return 0;
102137   }
102138   std::string arg3_str(jarg3);
102139   arg3 = &arg3_str;
102140   {
102141     try {
102142       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102143     } catch (std::out_of_range& e) {
102144       {
102145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102146       };
102147     } catch (std::exception& e) {
102148       {
102149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102150       };
102151     } catch (...) {
102152       {
102153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102154       };
102155     }
102156   }
102157   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102158
102159   return jresult;
102160 }
102161
102162
102163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102164   void * jresult ;
102165   Dali::WidgetApplication *result = 0 ;
102166
102167   {
102168     try {
102169       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102170     } catch (std::out_of_range& e) {
102171       {
102172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102173       };
102174     } catch (std::exception& e) {
102175       {
102176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102177       };
102178     } catch (...) {
102179       {
102180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102181       };
102182     }
102183   }
102184   jresult = (void *)result;
102185   return jresult;
102186 }
102187
102188
102189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102190   void * jresult ;
102191   Dali::WidgetApplication *arg1 = 0 ;
102192   Dali::WidgetApplication *result = 0 ;
102193
102194   arg1 = (Dali::WidgetApplication *)jarg1;
102195   if (!arg1) {
102196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102197     return 0;
102198   }
102199   {
102200     try {
102201       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102202     } catch (std::out_of_range& e) {
102203       {
102204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102205       };
102206     } catch (std::exception& e) {
102207       {
102208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102209       };
102210     } catch (...) {
102211       {
102212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102213       };
102214     }
102215   }
102216   jresult = (void *)result;
102217   return jresult;
102218 }
102219
102220
102221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102222   void * jresult ;
102223   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102224   Dali::WidgetApplication *arg2 = 0 ;
102225   Dali::WidgetApplication *result = 0 ;
102226
102227   arg1 = (Dali::WidgetApplication *)jarg1;
102228   arg2 = (Dali::WidgetApplication *)jarg2;
102229   if (!arg2) {
102230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102231     return 0;
102232   }
102233   {
102234     try {
102235       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102236     } catch (std::out_of_range& e) {
102237       {
102238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102239       };
102240     } catch (std::exception& e) {
102241       {
102242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102243       };
102244     } catch (...) {
102245       {
102246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102247       };
102248     }
102249   }
102250   jresult = (void *)result;
102251   return jresult;
102252 }
102253
102254
102255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102256   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102257
102258   arg1 = (Dali::WidgetApplication *)jarg1;
102259   {
102260     try {
102261       delete arg1;
102262       if( argWidgetV )
102263       {
102264         // free string data
102265         for( int i=0; i < argWidgetC+1; i++)
102266         {
102267           delete [] argWidgetV[i];
102268         }
102269         delete [] argWidgetV;
102270       }
102271     } catch (std::out_of_range& e) {
102272       {
102273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102274       };
102275     } catch (std::exception& e) {
102276       {
102277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102278       };
102279     } catch (...) {
102280       {
102281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102282       };
102283     }
102284   }
102285 }
102286
102287
102288 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102289 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102290
102291 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102292 {
102293   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102294   return *widget;
102295 }
102296
102297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102298   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102299   std::string *arg2 = 0 ;
102300
102301   arg1 = (Dali::WidgetApplication *)jarg1;
102302   if (!jarg2) {
102303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102304     return ;
102305   }
102306   std::string arg2_str(*jarg2);
102307   arg2 = &arg2_str;
102308
102309   if(!_CSharpCreateWidgetFunction)
102310   {
102311     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102312   }
102313
102314   {
102315     try {
102316       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102317     } catch (std::out_of_range& e) {
102318       {
102319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102320       };
102321     } catch (std::exception& e) {
102322       {
102323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102324       };
102325     } catch (...) {
102326       {
102327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102328       };
102329     }
102330   }
102331
102332   //Typemap argout in c++ file.
102333   //This will convert c++ string to c# string
102334   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102335 }
102336
102337
102338 //for PixelBuffer and ImageLoading
102339
102340 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102341     return (Dali::BaseHandle *)jarg1;
102342 }
102343
102344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102345   void * jresult ;
102346   unsigned int arg1 ;
102347   unsigned int arg2 ;
102348   Dali::Pixel::Format arg3 ;
102349   Dali::Devel::PixelBuffer result;
102350
102351   arg1 = (unsigned int)jarg1;
102352   arg2 = (unsigned int)jarg2;
102353   arg3 = (Dali::Pixel::Format)jarg3;
102354   {
102355     try {
102356       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102357     } catch (std::out_of_range& e) {
102358       {
102359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102360       };
102361     } catch (std::exception& e) {
102362       {
102363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102364       };
102365     } catch (...) {
102366       {
102367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102368       };
102369     }
102370   }
102371   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102372   return jresult;
102373 }
102374
102375
102376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102377   void * jresult ;
102378   Dali::Devel::PixelBuffer *result = 0 ;
102379
102380   {
102381     try {
102382       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102383     } catch (std::out_of_range& e) {
102384       {
102385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102386       };
102387     } catch (std::exception& e) {
102388       {
102389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102390       };
102391     } catch (...) {
102392       {
102393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102394       };
102395     }
102396   }
102397   jresult = (void *)result;
102398   return jresult;
102399 }
102400
102401
102402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102403   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102404
102405   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102406   {
102407     try {
102408       delete arg1;
102409     } catch (std::out_of_range& e) {
102410       {
102411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102412       };
102413     } catch (std::exception& e) {
102414       {
102415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102416       };
102417     } catch (...) {
102418       {
102419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102420       };
102421     }
102422   }
102423 }
102424
102425
102426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102427   void * jresult ;
102428   Dali::Devel::PixelBuffer *arg1 = 0 ;
102429   Dali::Devel::PixelBuffer *result = 0 ;
102430
102431   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102432   if (!arg1) {
102433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102434     return 0;
102435   }
102436   {
102437     try {
102438       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102439     } catch (std::out_of_range& e) {
102440       {
102441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102442       };
102443     } catch (std::exception& e) {
102444       {
102445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102446       };
102447     } catch (...) {
102448       {
102449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102450       };
102451     }
102452   }
102453   jresult = (void *)result;
102454   return jresult;
102455 }
102456
102457
102458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102459   void * jresult ;
102460   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102461   Dali::Devel::PixelBuffer *arg2 = 0 ;
102462   Dali::Devel::PixelBuffer *result = 0 ;
102463
102464   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102465   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102466   if (!arg2) {
102467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102468     return 0;
102469   }
102470   {
102471     try {
102472       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102473     } catch (std::out_of_range& e) {
102474       {
102475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102476       };
102477     } catch (std::exception& e) {
102478       {
102479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102480       };
102481     } catch (...) {
102482       {
102483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102484       };
102485     }
102486   }
102487   jresult = (void *)result;
102488   return jresult;
102489 }
102490
102491
102492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102493   void * jresult ;
102494   Dali::Devel::PixelBuffer *arg1 = 0 ;
102495   Dali::PixelData result;
102496
102497   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102498   if (!arg1) {
102499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102500     return 0;
102501   }
102502   {
102503     try {
102504       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102505     } catch (std::out_of_range& e) {
102506       {
102507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102508       };
102509     } catch (std::exception& e) {
102510       {
102511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102512       };
102513     } catch (...) {
102514       {
102515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102516       };
102517     }
102518   }
102519   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102520   return jresult;
102521 }
102522
102523
102524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102525   void * jresult ;
102526   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102527   Dali::PixelData result;
102528
102529   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102530   {
102531     try {
102532       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102533     } catch (std::out_of_range& e) {
102534       {
102535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102536       };
102537     } catch (std::exception& e) {
102538       {
102539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102540       };
102541     } catch (...) {
102542       {
102543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102544       };
102545     }
102546   }
102547   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102548   return jresult;
102549 }
102550
102551
102552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102553   void * jresult ;
102554   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102555   unsigned char *result = 0 ;
102556
102557   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102558   {
102559     try {
102560       result = (unsigned char *)(arg1)->GetBuffer();
102561     } catch (std::out_of_range& e) {
102562       {
102563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102564       };
102565     } catch (std::exception& e) {
102566       {
102567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102568       };
102569     } catch (...) {
102570       {
102571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102572       };
102573     }
102574   }
102575   jresult = (void *)result;
102576   return jresult;
102577 }
102578
102579
102580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102581   unsigned int jresult ;
102582   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102583   unsigned int result;
102584
102585   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102586   {
102587     try {
102588       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102589     } catch (std::out_of_range& e) {
102590       {
102591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102592       };
102593     } catch (std::exception& e) {
102594       {
102595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102596       };
102597     } catch (...) {
102598       {
102599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102600       };
102601     }
102602   }
102603   jresult = result;
102604   return jresult;
102605 }
102606
102607
102608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102609   unsigned int jresult ;
102610   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102611   unsigned int result;
102612
102613   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102614   {
102615     try {
102616       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102617     } catch (std::out_of_range& e) {
102618       {
102619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102620       };
102621     } catch (std::exception& e) {
102622       {
102623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102624       };
102625     } catch (...) {
102626       {
102627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102628       };
102629     }
102630   }
102631   jresult = result;
102632   return jresult;
102633 }
102634
102635
102636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102637   int jresult ;
102638   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102639   Dali::Pixel::Format result;
102640
102641   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102642   {
102643     try {
102644       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102645     } catch (std::out_of_range& e) {
102646       {
102647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102648       };
102649     } catch (std::exception& e) {
102650       {
102651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102652       };
102653     } catch (...) {
102654       {
102655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102656       };
102657     }
102658   }
102659   jresult = (int)result;
102660   return jresult;
102661 }
102662
102663
102664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102665   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102666   Dali::Devel::PixelBuffer arg2 ;
102667   float arg3 ;
102668   bool arg4 ;
102669   Dali::Devel::PixelBuffer *argp2 ;
102670
102671   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102672   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102673   if (!argp2) {
102674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102675     return ;
102676   }
102677   arg2 = *argp2;
102678   arg3 = (float)jarg3;
102679   arg4 = jarg4 ? true : false;
102680   {
102681     try {
102682       (arg1)->ApplyMask(arg2,arg3,arg4);
102683     } catch (std::out_of_range& e) {
102684       {
102685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102686       };
102687     } catch (std::exception& e) {
102688       {
102689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102690       };
102691     } catch (...) {
102692       {
102693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102694       };
102695     }
102696   }
102697 }
102698
102699
102700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102701   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102702   Dali::Devel::PixelBuffer arg2 ;
102703   float arg3 ;
102704   Dali::Devel::PixelBuffer *argp2 ;
102705
102706   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102707   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102708   if (!argp2) {
102709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102710     return ;
102711   }
102712   arg2 = *argp2;
102713   arg3 = (float)jarg3;
102714   {
102715     try {
102716       (arg1)->ApplyMask(arg2,arg3);
102717     } catch (std::out_of_range& e) {
102718       {
102719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102720       };
102721     } catch (std::exception& e) {
102722       {
102723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102724       };
102725     } catch (...) {
102726       {
102727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102728       };
102729     }
102730   }
102731 }
102732
102733
102734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102735   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102736   Dali::Devel::PixelBuffer arg2 ;
102737   Dali::Devel::PixelBuffer *argp2 ;
102738
102739   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102740   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102741   if (!argp2) {
102742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102743     return ;
102744   }
102745   arg2 = *argp2;
102746   {
102747     try {
102748       (arg1)->ApplyMask(arg2);
102749     } catch (std::out_of_range& e) {
102750       {
102751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102752       };
102753     } catch (std::exception& e) {
102754       {
102755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102756       };
102757     } catch (...) {
102758       {
102759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102760       };
102761     }
102762   }
102763 }
102764
102765
102766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102767   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102768   float arg2 ;
102769
102770   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102771   arg2 = (float)jarg2;
102772   {
102773     try {
102774       (arg1)->ApplyGaussianBlur(arg2);
102775     } catch (std::out_of_range& e) {
102776       {
102777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102778       };
102779     } catch (std::exception& e) {
102780       {
102781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102782       };
102783     } catch (...) {
102784       {
102785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102786       };
102787     }
102788   }
102789 }
102790
102791
102792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102793   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102794   uint16_t arg2 ;
102795   uint16_t arg3 ;
102796   uint16_t arg4 ;
102797   uint16_t arg5 ;
102798
102799   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102800   arg2 = (uint16_t)jarg2;
102801   arg3 = (uint16_t)jarg3;
102802   arg4 = (uint16_t)jarg4;
102803   arg5 = (uint16_t)jarg5;
102804   {
102805     try {
102806       (arg1)->Crop(arg2,arg3,arg4,arg5);
102807     } catch (std::out_of_range& e) {
102808       {
102809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102810       };
102811     } catch (std::exception& e) {
102812       {
102813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102814       };
102815     } catch (...) {
102816       {
102817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102818       };
102819     }
102820   }
102821 }
102822
102823
102824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102825   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102826   uint16_t arg2 ;
102827   uint16_t arg3 ;
102828
102829   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102830   arg2 = (uint16_t)jarg2;
102831   arg3 = (uint16_t)jarg3;
102832   {
102833     try {
102834       (arg1)->Resize(arg2,arg3);
102835     } catch (std::out_of_range& e) {
102836       {
102837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102838       };
102839     } catch (std::exception& e) {
102840       {
102841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102842       };
102843     } catch (...) {
102844       {
102845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102846       };
102847     }
102848   }
102849 }
102850
102851
102852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102853   void * jresult ;
102854   std::string *arg1 = 0 ;
102855   Dali::ImageDimensions arg2 ;
102856   Dali::FittingMode::Type arg3 ;
102857   Dali::SamplingMode::Type arg4 ;
102858   bool arg5 ;
102859   Dali::ImageDimensions *argp2 ;
102860   Dali::Devel::PixelBuffer result;
102861
102862   if (!jarg1) {
102863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102864     return 0;
102865   }
102866   std::string arg1_str(jarg1);
102867   arg1 = &arg1_str;
102868   argp2 = (Dali::ImageDimensions *)jarg2;
102869   if (!argp2) {
102870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102871     return 0;
102872   }
102873   arg2 = *argp2;
102874   arg3 = (Dali::FittingMode::Type)jarg3;
102875   arg4 = (Dali::SamplingMode::Type)jarg4;
102876   arg5 = jarg5 ? true : false;
102877   {
102878     try {
102879       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102880     } catch (std::out_of_range& e) {
102881       {
102882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102883       };
102884     } catch (std::exception& e) {
102885       {
102886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102887       };
102888     } catch (...) {
102889       {
102890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102891       };
102892     }
102893   }
102894   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102895
102896   return jresult;
102897 }
102898
102899
102900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102901   void * jresult ;
102902   std::string *arg1 = 0 ;
102903   Dali::ImageDimensions arg2 ;
102904   Dali::FittingMode::Type arg3 ;
102905   Dali::SamplingMode::Type arg4 ;
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   {
102924     try {
102925       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102926     } catch (std::out_of_range& e) {
102927       {
102928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102929       };
102930     } catch (std::exception& e) {
102931       {
102932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102933       };
102934     } catch (...) {
102935       {
102936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102937       };
102938     }
102939   }
102940   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102941
102942   return jresult;
102943 }
102944
102945
102946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102947   void * jresult ;
102948   std::string *arg1 = 0 ;
102949   Dali::ImageDimensions arg2 ;
102950   Dali::FittingMode::Type arg3 ;
102951   Dali::ImageDimensions *argp2 ;
102952   Dali::Devel::PixelBuffer result;
102953
102954   if (!jarg1) {
102955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102956     return 0;
102957   }
102958   std::string arg1_str(jarg1);
102959   arg1 = &arg1_str;
102960   argp2 = (Dali::ImageDimensions *)jarg2;
102961   if (!argp2) {
102962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102963     return 0;
102964   }
102965   arg2 = *argp2;
102966   arg3 = (Dali::FittingMode::Type)jarg3;
102967   {
102968     try {
102969       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102970     } catch (std::out_of_range& e) {
102971       {
102972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102973       };
102974     } catch (std::exception& e) {
102975       {
102976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102977       };
102978     } catch (...) {
102979       {
102980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102981       };
102982     }
102983   }
102984   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102985
102986   return jresult;
102987 }
102988
102989
102990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102991   void * jresult ;
102992   std::string *arg1 = 0 ;
102993   Dali::ImageDimensions arg2 ;
102994   Dali::ImageDimensions *argp2 ;
102995   Dali::Devel::PixelBuffer result;
102996
102997   if (!jarg1) {
102998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102999     return 0;
103000   }
103001   std::string arg1_str(jarg1);
103002   arg1 = &arg1_str;
103003   argp2 = (Dali::ImageDimensions *)jarg2;
103004   if (!argp2) {
103005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103006     return 0;
103007   }
103008   arg2 = *argp2;
103009   {
103010     try {
103011       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103012     } catch (std::out_of_range& e) {
103013       {
103014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103015       };
103016     } catch (std::exception& e) {
103017       {
103018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103019       };
103020     } catch (...) {
103021       {
103022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103023       };
103024     }
103025   }
103026   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103027
103028   return jresult;
103029 }
103030
103031
103032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103033   void * jresult ;
103034   std::string *arg1 = 0 ;
103035   Dali::Devel::PixelBuffer result;
103036
103037   if (!jarg1) {
103038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103039     return 0;
103040   }
103041   std::string arg1_str(jarg1);
103042   arg1 = &arg1_str;
103043   {
103044     try {
103045       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103046     } catch (std::out_of_range& e) {
103047       {
103048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103049       };
103050     } catch (std::exception& e) {
103051       {
103052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103053       };
103054     } catch (...) {
103055       {
103056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103057       };
103058     }
103059   }
103060   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103061
103062   return jresult;
103063 }
103064
103065
103066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103067   void * jresult ;
103068   std::string *arg1 = 0 ;
103069   Dali::ImageDimensions arg2 ;
103070   Dali::FittingMode::Type arg3 ;
103071   Dali::SamplingMode::Type arg4 ;
103072   bool arg5 ;
103073   Dali::ImageDimensions *argp2 ;
103074   Dali::ImageDimensions result;
103075
103076   if (!jarg1) {
103077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103078     return 0;
103079   }
103080   std::string arg1_str(jarg1);
103081   arg1 = &arg1_str;
103082   argp2 = (Dali::ImageDimensions *)jarg2;
103083   if (!argp2) {
103084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103085     return 0;
103086   }
103087   arg2 = *argp2;
103088   arg3 = (Dali::FittingMode::Type)jarg3;
103089   arg4 = (Dali::SamplingMode::Type)jarg4;
103090   arg5 = jarg5 ? true : false;
103091   {
103092     try {
103093       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103094     } catch (std::out_of_range& e) {
103095       {
103096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103097       };
103098     } catch (std::exception& e) {
103099       {
103100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103101       };
103102     } catch (...) {
103103       {
103104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103105       };
103106     }
103107   }
103108   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103109
103110   return jresult;
103111 }
103112
103113
103114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103115   void * jresult ;
103116   std::string *arg1 = 0 ;
103117   Dali::ImageDimensions arg2 ;
103118   Dali::FittingMode::Type arg3 ;
103119   Dali::SamplingMode::Type arg4 ;
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   {
103138     try {
103139       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103140     } catch (std::out_of_range& e) {
103141       {
103142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103143       };
103144     } catch (std::exception& e) {
103145       {
103146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103147       };
103148     } catch (...) {
103149       {
103150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103151       };
103152     }
103153   }
103154   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103155
103156   return jresult;
103157 }
103158
103159
103160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103161   void * jresult ;
103162   std::string *arg1 = 0 ;
103163   Dali::ImageDimensions arg2 ;
103164   Dali::FittingMode::Type arg3 ;
103165   Dali::ImageDimensions *argp2 ;
103166   Dali::ImageDimensions result;
103167
103168   if (!jarg1) {
103169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103170     return 0;
103171   }
103172   std::string arg1_str(jarg1);
103173   arg1 = &arg1_str;
103174   argp2 = (Dali::ImageDimensions *)jarg2;
103175   if (!argp2) {
103176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103177     return 0;
103178   }
103179   arg2 = *argp2;
103180   arg3 = (Dali::FittingMode::Type)jarg3;
103181   {
103182     try {
103183       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103184     } catch (std::out_of_range& e) {
103185       {
103186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103187       };
103188     } catch (std::exception& e) {
103189       {
103190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103191       };
103192     } catch (...) {
103193       {
103194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103195       };
103196     }
103197   }
103198   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103199
103200   return jresult;
103201 }
103202
103203
103204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103205   void * jresult ;
103206   std::string *arg1 = 0 ;
103207   Dali::ImageDimensions arg2 ;
103208   Dali::ImageDimensions *argp2 ;
103209   Dali::ImageDimensions result;
103210
103211   if (!jarg1) {
103212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103213     return 0;
103214   }
103215   std::string arg1_str(jarg1);
103216   arg1 = &arg1_str;
103217   argp2 = (Dali::ImageDimensions *)jarg2;
103218   if (!argp2) {
103219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103220     return 0;
103221   }
103222   arg2 = *argp2;
103223   {
103224     try {
103225       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103226     } catch (std::out_of_range& e) {
103227       {
103228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103229       };
103230     } catch (std::exception& e) {
103231       {
103232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103233       };
103234     } catch (...) {
103235       {
103236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103237       };
103238     }
103239   }
103240   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103241
103242   return jresult;
103243 }
103244
103245
103246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103247   void * jresult ;
103248   std::string *arg1 = 0 ;
103249   Dali::ImageDimensions result;
103250
103251   if (!jarg1) {
103252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103253     return 0;
103254   }
103255   std::string arg1_str(jarg1);
103256   arg1 = &arg1_str;
103257   {
103258     try {
103259       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103260     } catch (std::out_of_range& e) {
103261       {
103262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103263       };
103264     } catch (std::exception& e) {
103265       {
103266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103267       };
103268     } catch (...) {
103269       {
103270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103271       };
103272     }
103273   }
103274   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103275
103276   return jresult;
103277 }
103278
103279
103280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103281   void * jresult ;
103282   std::string *arg1 = 0 ;
103283   Dali::ImageDimensions arg2 ;
103284   Dali::FittingMode::Type arg3 ;
103285   Dali::SamplingMode::Type arg4 ;
103286   bool arg5 ;
103287   Dali::ImageDimensions *argp2 ;
103288   Dali::Devel::PixelBuffer result;
103289
103290   if (!jarg1) {
103291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103292     return 0;
103293   }
103294   std::string arg1_str(jarg1);
103295   arg1 = &arg1_str;
103296   argp2 = (Dali::ImageDimensions *)jarg2;
103297   if (!argp2) {
103298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103299     return 0;
103300   }
103301   arg2 = *argp2;
103302   arg3 = (Dali::FittingMode::Type)jarg3;
103303   arg4 = (Dali::SamplingMode::Type)jarg4;
103304   arg5 = jarg5 ? true : false;
103305   {
103306     try {
103307       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103308     } catch (std::out_of_range& e) {
103309       {
103310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103311       };
103312     } catch (std::exception& e) {
103313       {
103314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103315       };
103316     } catch (...) {
103317       {
103318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103319       };
103320     }
103321   }
103322   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103323
103324   return jresult;
103325 }
103326
103327
103328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103329   void * jresult ;
103330   std::string *arg1 = 0 ;
103331   Dali::ImageDimensions arg2 ;
103332   Dali::FittingMode::Type arg3 ;
103333   Dali::SamplingMode::Type arg4 ;
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   {
103352     try {
103353       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103354     } catch (std::out_of_range& e) {
103355       {
103356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103357       };
103358     } catch (std::exception& e) {
103359       {
103360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103361       };
103362     } catch (...) {
103363       {
103364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103365       };
103366     }
103367   }
103368   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103369
103370   return jresult;
103371 }
103372
103373
103374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103375   void * jresult ;
103376   std::string *arg1 = 0 ;
103377   Dali::ImageDimensions arg2 ;
103378   Dali::FittingMode::Type arg3 ;
103379   Dali::ImageDimensions *argp2 ;
103380   Dali::Devel::PixelBuffer result;
103381
103382   if (!jarg1) {
103383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103384     return 0;
103385   }
103386   std::string arg1_str(jarg1);
103387   arg1 = &arg1_str;
103388   argp2 = (Dali::ImageDimensions *)jarg2;
103389   if (!argp2) {
103390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103391     return 0;
103392   }
103393   arg2 = *argp2;
103394   arg3 = (Dali::FittingMode::Type)jarg3;
103395   {
103396     try {
103397       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103398     } catch (std::out_of_range& e) {
103399       {
103400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103401       };
103402     } catch (std::exception& e) {
103403       {
103404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103405       };
103406     } catch (...) {
103407       {
103408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103409       };
103410     }
103411   }
103412   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103413
103414   return jresult;
103415 }
103416
103417
103418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103419   void * jresult ;
103420   std::string *arg1 = 0 ;
103421   Dali::ImageDimensions arg2 ;
103422   Dali::ImageDimensions *argp2 ;
103423   Dali::Devel::PixelBuffer result;
103424
103425   if (!jarg1) {
103426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103427     return 0;
103428   }
103429   std::string arg1_str(jarg1);
103430   arg1 = &arg1_str;
103431   argp2 = (Dali::ImageDimensions *)jarg2;
103432   if (!argp2) {
103433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103434     return 0;
103435   }
103436   arg2 = *argp2;
103437   {
103438     try {
103439       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103440     } catch (std::out_of_range& e) {
103441       {
103442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103443       };
103444     } catch (std::exception& e) {
103445       {
103446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103447       };
103448     } catch (...) {
103449       {
103450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103451       };
103452     }
103453   }
103454   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103455
103456   return jresult;
103457 }
103458
103459
103460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103461   void * jresult ;
103462   std::string *arg1 = 0 ;
103463   Dali::Devel::PixelBuffer result;
103464
103465   if (!jarg1) {
103466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103467     return 0;
103468   }
103469   std::string arg1_str(jarg1);
103470   arg1 = &arg1_str;
103471   {
103472     try {
103473       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103474     } catch (std::out_of_range& e) {
103475       {
103476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103477       };
103478     } catch (std::exception& e) {
103479       {
103480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103481       };
103482     } catch (...) {
103483       {
103484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103485       };
103486     }
103487   }
103488   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103489
103490   return jresult;
103491 }
103492
103493
103494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103495   unsigned int arg1 ;
103496
103497   arg1 = (unsigned int)jarg1;
103498   {
103499     try {
103500       Dali::SetMaxTextureSize(arg1);
103501     } catch (std::out_of_range& e) {
103502       {
103503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103504       };
103505     } catch (std::exception& e) {
103506       {
103507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103508       };
103509     } catch (...) {
103510       {
103511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103512       };
103513     }
103514   }
103515 }
103516
103517
103518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103519   unsigned int jresult ;
103520   unsigned int result;
103521
103522   {
103523     try {
103524       result = (unsigned int)Dali::GetMaxTextureSize();
103525     } catch (std::out_of_range& e) {
103526       {
103527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103528       };
103529     } catch (std::exception& e) {
103530       {
103531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103532       };
103533     } catch (...) {
103534       {
103535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103536       };
103537     }
103538   }
103539   jresult = result;
103540   return jresult;
103541 }
103542
103543
103544 #ifdef __cplusplus
103545 }
103546 #endif
103547